@agentica/core 0.10.4 → 0.11.0

package/lib/chatgpt/ChatGptCompletionMessageUtil.js

@@ -0,0 +1,536 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatGptCompletionMessageUtil = void 0;
+const __typia_transform__assertGuard = __importStar(require("typia/lib/internal/_assertGuard.js"));
+const typia_1 = require("typia");
+const ByteArrayUtil_1 = require("../internal/ByteArrayUtil");
+const ChatGptUsageAggregator_1 = require("./ChatGptUsageAggregator");
+var ChatGptCompletionMessageUtil;
+(function (ChatGptCompletionMessageUtil) {
+    ChatGptCompletionMessageUtil.transformCompletionChunk = (source) => {
+        const str = source instanceof Uint8Array ? ByteArrayUtil_1.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 + "]", true && _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", true && _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", true && _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", true && _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", true && _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 + "]", true && _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\"]", true && _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 + "]", true && _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 + "]", true && _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 + "]", true && _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", true && _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", true && _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) => {
+            var _a, _b, _c, _d;
+            const accChoice = choices[choice.index];
+            if (accChoice) {
+                choices[choice.index] = ChatGptCompletionMessageUtil.mergeChoice(accChoice, choice);
+                return;
+            }
+            choices[choice.index] = {
+                index: choice.index,
+                finish_reason: (_a = choice.finish_reason) !== null && _a !== void 0 ? _a : null,
+                logprobs: (_b = choice.logprobs) !== null && _b !== void 0 ? _b : null,
+                message: {
+                    tool_calls: choice.delta.tool_calls
+                        ? choice.delta.tool_calls.reduce((acc, cur) => {
+                            var _a, _b, _c, _d, _e;
+                            acc[cur.index] = {
+                                id: (_a = cur.id) !== null && _a !== void 0 ? _a : "",
+                                type: "function",
+                                function: {
+                                    name: (_c = (_b = cur.function) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : "",
+                                    arguments: (_e = (_d = cur.function) === null || _d === void 0 ? void 0 : _d.arguments) !== null && _e !== void 0 ? _e : "",
+                                },
+                            };
+                            return acc;
+                        }, [])
+                        : undefined,
+                    content: (_c = choice.delta.content) !== null && _c !== void 0 ? _c : null,
+                    refusal: (_d = choice.delta.refusal) !== null && _d !== void 0 ? _d : null,
+                    role: "assistant",
+                },
+            };
+        });
+        const usage = (() => {
+            if (!chunk.usage) {
+                return origin.usage;
+            }
+            if (!origin.usage) {
+                return chunk.usage;
+            }
+            return ChatGptUsageAggregator_1.ChatGptUsageAggregator.sum(origin.usage, chunk.usage);
+        })();
+        return Object.assign(Object.assign({}, 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;
+        var _b;
+        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 = (_b = acc.message).tool_calls) !== null && _a !== void 0 ? _a : (_b.tool_calls = []);
+            const toolCalls = acc.message.tool_calls;
+            cur.delta.tool_calls.forEach((toolCall) => {
+                var _a, _b, _c, _d, _e;
+                const existingToolCall = toolCalls[toolCall.index];
+                if (existingToolCall) {
+                    toolCalls[toolCall.index] = ChatGptCompletionMessageUtil.mergeToolCalls(existingToolCall, toolCall);
+                    return;
+                }
+                toolCalls[toolCall.index] = {
+                    id: (_a = toolCall.id) !== null && _a !== void 0 ? _a : "",
+                    type: "function",
+                    function: {
+                        name: (_c = (_b = toolCall.function) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : "",
+                        arguments: (_e = (_d = toolCall.function) === null || _d === void 0 ? void 0 : _d.arguments) !== null && _e !== void 0 ? _e : "",
+                    },
+                };
+            });
+        }
+        return acc;
+    };
+    ChatGptCompletionMessageUtil.mergeToolCalls = (acc, cur) => {
+        var _a, _b, _c;
+        if (cur.function) {
+            acc.function.arguments += (_a = cur.function.arguments) !== null && _a !== void 0 ? _a : "";
+            acc.function.name += (_b = cur.function.name) !== null && _b !== void 0 ? _b : "";
+        }
+        acc.id += (_c = cur.id) !== null && _c !== void 0 ? _c : "";
+        return acc;
+    };
+})(ChatGptCompletionMessageUtil || (exports.ChatGptCompletionMessageUtil = ChatGptCompletionMessageUtil = {}));
+//# sourceMappingURL=ChatGptCompletionMessageUtil.js.map

package/lib/chatgpt/ChatGptCompletionMessageUtil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatGptCompletionMessageUtil.js","sourceRoot":"","sources":["../../src/chatgpt/ChatGptCompletionMessageUtil.ts"],"names":[],"mappings":"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"}

package/lib/chatgpt/ChatGptDescribeFunctionAgent.d.ts

@@ -1,6 +1,7 @@
 import { ILlmSchema } from "@samchon/openapi";
-import { IAgenticaContext } from "../structures/IAgenticaContext";
-import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
+import { AgenticaContext } from "../context/AgenticaContext";
+import { AgenticaDescribePrompt } from "../prompts/AgenticaDescribePrompt";
+import { AgenticaExecutePrompt } from "../prompts/AgenticaExecutePrompt";
 export declare namespace ChatGptDescribeFunctionAgent {
-    const execute: <Model extends ILlmSchema.Model>(ctx: IAgenticaContext<Model>, histories: IAgenticaPrompt.IExecute<Model>[]) => Promise<IAgenticaPrompt.IDescribe<Model>[]>;
+    const execute: <Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>, histories: AgenticaExecutePrompt<Model>[]) => Promise<AgenticaDescribePrompt<Model>[]>;
 }