@agentica/core 0.24.0 → 0.26.0

package/lib/functional/validateMcpController.js

@@ -77,7 +77,7 @@ function validateMcpController(props) {
             if (undefined === value)
                 return true;
             return "object" === typeof value && null !== value && false === Array.isArray(value) && _iu0(value);
-        }); const _io3 = input => (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io2(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu0(input.additionalProperties))) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && "object" === input.type && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (null !== input.examples && (undefined === input.examples || (Array.isArray(input.examples) || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io5(input.examples)))); const _io4 = input => Array.isArray(input.type) && input.type.every(elem => "string" === elem || "number" === elem || "boolean" === elem || "object" === elem || "integer" === elem || "array" === elem || "null" === elem) && (null === input["default"] || undefined === input["default"] || Array.isArray(input["default"])) && (undefined === input["enum"] || Array.isArray(input["enum"])) && ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (undefined === input.nullable || "boolean" === typeof input.nullable) && (null !== input.examples && (undefined === input.examples || (Array.isArray(input.examples) || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io5(input.examples)))) && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || "boolean" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || "boolean" === typeof input.exclusiveMaximum) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (null !== input.items && (undefined === input.items || (Array.isArray(input.items) && input.items.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem)) || "object" === typeof input.items && null !== input.items && false === Array.isArray(input.items) && _iu0(input.items)))) && (undefined === input.prefixItems || Array.isArray(input.prefixItems) && input.prefixItems.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (null !== input.additionalItems && (undefined === input.additionalItems || "boolean" === typeof input.additionalItems || "object" === typeof input.additionalItems && null !== input.additionalItems && false === Array.isArray(input.additionalItems) && _iu0(input.additionalItems))) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 18446744073709552000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 18446744073709552000)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu0(input.additionalProperties))) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io2(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && (Array.isArray(input.oneOf) && input.oneOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io17(input.discriminator)) && (Array.isArray(input.anyOf) && input.anyOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (Array.isArray(input.allOf) && input.allOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && "string" === typeof input.$ref; const _io5 = input => Object.keys(input).every(key => {
+        }); const _io3 = input => (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io2(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu0(input.additionalProperties))) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && "object" === input.type && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (null !== input.examples && (undefined === input.examples || (Array.isArray(input.examples) || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io5(input.examples)))); const _io4 = input => Array.isArray(input.type) && input.type.every(elem => "string" === elem || "number" === elem || "boolean" === elem || "object" === elem || "integer" === elem || "array" === elem || "null" === elem) && (null === input["default"] || undefined === input["default"] || Array.isArray(input["default"])) && (undefined === input["enum"] || Array.isArray(input["enum"])) && ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (undefined === input.nullable || "boolean" === typeof input.nullable) && (null !== input.examples && (undefined === input.examples || (Array.isArray(input.examples) || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io5(input.examples)))) && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || "boolean" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || "boolean" === typeof input.exclusiveMaximum) && (undefined === input.format || "string" === typeof input.format) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (null !== input.items && (undefined === input.items || (Array.isArray(input.items) && input.items.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem)) || "object" === typeof input.items && null !== input.items && false === Array.isArray(input.items) && _iu0(input.items)))) && (undefined === input.prefixItems || Array.isArray(input.prefixItems) && input.prefixItems.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (null !== input.additionalItems && (undefined === input.additionalItems || "boolean" === typeof input.additionalItems || "object" === typeof input.additionalItems && null !== input.additionalItems && false === Array.isArray(input.additionalItems) && _iu0(input.additionalItems))) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 18446744073709552000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 18446744073709552000)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu0(input.additionalProperties))) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io2(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && (Array.isArray(input.oneOf) && input.oneOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io17(input.discriminator)) && (Array.isArray(input.anyOf) && input.anyOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (Array.isArray(input.allOf) && input.allOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && "string" === typeof input.$ref; const _io5 = input => Object.keys(input).every(key => {
             const value = input[key];
             if (undefined === value)
                 return true;
@@ -389,6 +389,10 @@ function validateMcpController(props) {
                 path: _path + ".exclusiveMaximum",
                 expected: "(boolean | number | undefined)",
                 value: input.exclusiveMaximum
+            }), undefined === input.format || "string" === typeof input.format || _report(_exceptionable, {
+                path: _path + ".format",
+                expected: "(string | undefined)",
+                value: input.format
             }), undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000 || _report(_exceptionable, {
                 path: _path + ".maxLength",
                 expected: "number & Type<\"uint64\">",
@@ -397,10 +401,6 @@ function validateMcpController(props) {
                 path: _path + ".maxLength",
                 expected: "((number & Type<\"uint64\">) | undefined)",
                 value: input.maxLength
-            }), undefined === input.format || "string" === typeof input.format || _report(_exceptionable, {
-                path: _path + ".format",
-                expected: "(string | undefined)",
-                value: input.format
             }), undefined === input.pattern || "string" === typeof input.pattern || _report(_exceptionable, {
                 path: _path + ".pattern",
                 expected: "(string | undefined)",
@@ -1410,7 +1410,7 @@ function validateMcpController(props) {
                 if (undefined === value)
                     return true;
                 return "object" === typeof value && null !== value && false === Array.isArray(value) && _iu0(value);
-            }); const _io3 = input => (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io2(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu0(input.additionalProperties))) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && "object" === input.type && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (null !== input.examples && (undefined === input.examples || (Array.isArray(input.examples) || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io5(input.examples)))); const _io4 = input => Array.isArray(input.type) && input.type.every(elem => "string" === elem || "number" === elem || "boolean" === elem || "object" === elem || "integer" === elem || "array" === elem || "null" === elem) && (null === input["default"] || undefined === input["default"] || Array.isArray(input["default"])) && (undefined === input["enum"] || Array.isArray(input["enum"])) && ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (undefined === input.nullable || "boolean" === typeof input.nullable) && (null !== input.examples && (undefined === input.examples || (Array.isArray(input.examples) || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io5(input.examples)))) && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || "boolean" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || "boolean" === typeof input.exclusiveMaximum) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (null !== input.items && (undefined === input.items || (Array.isArray(input.items) && input.items.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem)) || "object" === typeof input.items && null !== input.items && false === Array.isArray(input.items) && _iu0(input.items)))) && (undefined === input.prefixItems || Array.isArray(input.prefixItems) && input.prefixItems.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (null !== input.additionalItems && (undefined === input.additionalItems || "boolean" === typeof input.additionalItems || "object" === typeof input.additionalItems && null !== input.additionalItems && false === Array.isArray(input.additionalItems) && _iu0(input.additionalItems))) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 18446744073709552000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 18446744073709552000)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu0(input.additionalProperties))) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io2(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && (Array.isArray(input.oneOf) && input.oneOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io17(input.discriminator)) && (Array.isArray(input.anyOf) && input.anyOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (Array.isArray(input.allOf) && input.allOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && "string" === typeof input.$ref; const _io5 = input => Object.keys(input).every(key => {
+            }); const _io3 = input => (undefined === input.nullable || "boolean" === typeof input.nullable) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io2(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu0(input.additionalProperties))) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && "object" === input.type && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (null !== input.examples && (undefined === input.examples || (Array.isArray(input.examples) || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io5(input.examples)))); const _io4 = input => Array.isArray(input.type) && input.type.every(elem => "string" === elem || "number" === elem || "boolean" === elem || "object" === elem || "integer" === elem || "array" === elem || "null" === elem) && (null === input["default"] || undefined === input["default"] || Array.isArray(input["default"])) && (undefined === input["enum"] || Array.isArray(input["enum"])) && ("string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]) && (undefined === input.nullable || "boolean" === typeof input.nullable) && (null !== input.examples && (undefined === input.examples || (Array.isArray(input.examples) || "object" === typeof input.examples && null !== input.examples && false === Array.isArray(input.examples) && _io5(input.examples)))) && (undefined === input.title || "string" === typeof input.title) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.deprecated || "boolean" === typeof input.deprecated) && true && (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum || "boolean" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum || "boolean" === typeof input.exclusiveMaximum) && (undefined === input.format || "string" === typeof input.format) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (null !== input.items && (undefined === input.items || (Array.isArray(input.items) && input.items.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem)) || "object" === typeof input.items && null !== input.items && false === Array.isArray(input.items) && _iu0(input.items)))) && (undefined === input.prefixItems || Array.isArray(input.prefixItems) && input.prefixItems.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (null !== input.additionalItems && (undefined === input.additionalItems || "boolean" === typeof input.additionalItems || "object" === typeof input.additionalItems && null !== input.additionalItems && false === Array.isArray(input.additionalItems) && _iu0(input.additionalItems))) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 18446744073709552000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 18446744073709552000)) && (null !== input.additionalProperties && (undefined === input.additionalProperties || "boolean" === typeof input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && false === Array.isArray(input.additionalProperties) && _iu0(input.additionalProperties))) && (undefined === input.properties || "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io2(input.properties)) && (undefined === input.required || Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && (undefined === input.maxProperties || "number" === typeof input.maxProperties) && (undefined === input.minProperties || "number" === typeof input.minProperties) && (Array.isArray(input.oneOf) && input.oneOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io17(input.discriminator)) && (Array.isArray(input.anyOf) && input.anyOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && (Array.isArray(input.allOf) && input.allOf.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _iu0(elem))) && "string" === typeof input.$ref; const _io5 = input => Object.keys(input).every(key => {
                 const value = input[key];
                 if (undefined === value)
                     return true;
@@ -1786,6 +1786,11 @@ function validateMcpController(props) {
                 path: _path + ".exclusiveMaximum",
                 expected: "(boolean | number | undefined)",
                 value: input.exclusiveMaximum
+            }, _errorFactory)) && (undefined === input.format || "string" === typeof input.format || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".format",
+                expected: "(string | undefined)",
+                value: input.format
             }, _errorFactory)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".maxLength",
@@ -1796,11 +1801,6 @@ function validateMcpController(props) {
                 path: _path + ".maxLength",
                 expected: "((number & Type<\"uint64\">) | undefined)",
                 value: input.maxLength
-            }, _errorFactory)) && (undefined === input.format || "string" === typeof input.format || __typia_transform__assertGuard._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".format",
-                expected: "(string | undefined)",
-                value: input.format
             }, _errorFactory)) && (undefined === input.pattern || "string" === typeof input.pattern || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".pattern",

package/lib/functional/validateMcpController.js.map

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

package/lib/histories/AgenticaAssistantMessageHistory.d.ts

@@ -0,0 +1,5 @@
+import type { IAgenticaHistoryJson } from "../json/IAgenticaHistoryJson";
+import type { AgenticaHistoryBase } from "./AgenticaHistoryBase";
+export interface AgenticaAssistantMessageHistory extends AgenticaHistoryBase<"assistantMessage", IAgenticaHistoryJson.IAssistantMessage> {
+    text: string;
+}

package/lib/histories/AgenticaAssistantMessageHistory.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AgenticaAssistantMessageHistory.js.map

package/lib/histories/AgenticaAssistantMessageHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgenticaAssistantMessageHistory.js","sourceRoot":"","sources":["../../src/histories/AgenticaAssistantMessageHistory.ts"],"names":[],"mappings":""}

package/lib/histories/AgenticaHistory.d.ts

@@ -1,19 +1,21 @@
 import type { ILlmSchema } from "@samchon/openapi";
+import type { AgenticaAssistantMessageHistory } from "./AgenticaAssistantMessageHistory";
 import type { AgenticaCancelHistory } from "./AgenticaCancelHistory";
 import type { AgenticaDescribeHistory } from "./AgenticaDescribeHistory";
 import type { AgenticaExecuteHistory } from "./AgenticaExecuteHistory";
 import type { AgenticaSelectHistory } from "./AgenticaSelectHistory";
-import type { AgenticaTextHistory } from "./AgenticaTextHistory";
-import type { AgenticaUserInputHistory } from "./AgenticaUserInputHistory";
-export type AgenticaHistory<Model extends ILlmSchema.Model> = AgenticaCancelHistory<Model> | AgenticaDescribeHistory<Model> | AgenticaExecuteHistory<Model> | AgenticaSelectHistory<Model> | AgenticaTextHistory | AgenticaUserInputHistory;
+import type { AgenticaSystemMessageHistory } from "./AgenticaSystemMessageHistory";
+import type { AgenticaUserMessageHistory } from "./AgenticaUserMessageHistory";
+export type AgenticaHistory<Model extends ILlmSchema.Model> = AgenticaCancelHistory<Model> | AgenticaDescribeHistory<Model> | AgenticaExecuteHistory<Model> | AgenticaSelectHistory<Model> | AgenticaAssistantMessageHistory | AgenticaUserMessageHistory | AgenticaSystemMessageHistory;
 export declare namespace AgenticaHistory {
     type Type = AgenticaHistory<any>["type"];
     interface Mapper<Model extends ILlmSchema.Model> {
+        select: AgenticaSelectHistory<Model>;
         cancel: AgenticaCancelHistory<Model>;
-        describe: AgenticaDescribeHistory<Model>;
         execute: AgenticaExecuteHistory<Model>;
-        select: AgenticaSelectHistory<Model>;
-        text: AgenticaTextHistory;
-        user_input: AgenticaUserInputHistory;
+        describe: AgenticaDescribeHistory<Model>;
+        assistantMessage: AgenticaAssistantMessageHistory;
+        systemMessage: AgenticaSystemMessageHistory;
+        userMessage: AgenticaUserMessageHistory;
     }
 }

package/lib/histories/{AgenticaTextHistory.d.ts → AgenticaSystemMessageHistory.d.ts}

@@ -1,6 +1,5 @@
 import type { IAgenticaHistoryJson } from "../json/IAgenticaHistoryJson";
 import type { AgenticaHistoryBase } from "./AgenticaHistoryBase";
-export interface AgenticaTextHistory extends AgenticaHistoryBase<"text", IAgenticaHistoryJson.IText> {
-    role: "assistant";
+export interface AgenticaSystemMessageHistory extends AgenticaHistoryBase<"systemMessage", IAgenticaHistoryJson.ISystemMessage> {
     text: string;
 }

package/lib/histories/{AgenticaUserInputHistory.js → AgenticaSystemMessageHistory.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=AgenticaUserInputHistory.js.map
+//# sourceMappingURL=AgenticaSystemMessageHistory.js.map

package/lib/histories/AgenticaSystemMessageHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgenticaSystemMessageHistory.js","sourceRoot":"","sources":["../../src/histories/AgenticaSystemMessageHistory.ts"],"names":[],"mappings":""}

package/lib/histories/AgenticaUserMessageHistory.d.ts

@@ -0,0 +1,6 @@
+import type { IAgenticaHistoryJson } from "../json/IAgenticaHistoryJson";
+import type { AgenticaHistoryBase } from "./AgenticaHistoryBase";
+import type { AgenticaUserMessageContent } from "./contents/AgenticaUserMessageContent";
+export interface AgenticaUserMessageHistory extends AgenticaHistoryBase<"userMessage", IAgenticaHistoryJson.IUserMessage> {
+    contents: AgenticaUserMessageContent[];
+}

package/lib/{events/AgenticaTextEvent.js → histories/AgenticaUserMessageHistory.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=AgenticaTextEvent.js.map
+//# sourceMappingURL=AgenticaUserMessageHistory.js.map

package/lib/histories/AgenticaUserMessageHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgenticaUserMessageHistory.js","sourceRoot":"","sources":["../../src/histories/AgenticaUserMessageHistory.ts"],"names":[],"mappings":""}

package/lib/histories/MicroAgenticaHistory.d.ts

@@ -1,14 +1,15 @@
 import type { ILlmSchema } from "@samchon/openapi";
+import type { AgenticaAssistantMessageHistory } from "./AgenticaAssistantMessageHistory";
 import type { AgenticaDescribeHistory } from "./AgenticaDescribeHistory";
 import type { AgenticaExecuteHistory } from "./AgenticaExecuteHistory";
-import type { AgenticaTextHistory } from "./AgenticaTextHistory";
-import type { AgenticaUserInputHistory } from "./AgenticaUserInputHistory";
-export type MicroAgenticaHistory<Model extends ILlmSchema.Model> = AgenticaDescribeHistory<Model> | AgenticaExecuteHistory<Model> | AgenticaTextHistory | AgenticaUserInputHistory;
+import type { AgenticaUserMessageHistory } from "./AgenticaUserMessageHistory";
+export type MicroAgenticaHistory<Model extends ILlmSchema.Model> = AgenticaDescribeHistory<Model> | AgenticaExecuteHistory<Model> | AgenticaAssistantMessageHistory | AgenticaUserMessageHistory;
 export declare namespace MicroAgenticaHistory {
     type Type = MicroAgenticaHistory<any>["type"];
     interface Mapper<Model extends ILlmSchema.Model> {
         describe: AgenticaDescribeHistory<Model>;
         execute: AgenticaExecuteHistory<Model>;
-        text: AgenticaTextHistory;
+        userMessage: AgenticaUserMessageHistory;
+        assistantMessage: AgenticaAssistantMessageHistory;
     }
 }

package/lib/histories/contents/AgenticaUserMessageAudioContent.d.ts

@@ -0,0 +1,19 @@
+import type { AgenticaUserMessageContentBase } from "./AgenticaUserMessageContentBase";
+/**
+ * Audio content by user.
+ *
+ * @reference https://platform.openai.com/docs/guides/audio
+ * @warning We not recommend it because audio data only support base64
+ *          so it's too big data
+ * @author SunRabbit
+ */
+export interface AgenticaUserMessageAudioContent extends AgenticaUserMessageContentBase<"audio"> {
+    /**
+     * Base64 encoded audio data.
+     */
+    data: string;
+    /**
+     * The format of the encoded audio data. Currently supports "wav" and "mp3".
+     */
+    format: "wav" | "mp3";
+}

package/lib/histories/contents/AgenticaUserMessageAudioContent.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AgenticaUserMessageAudioContent.js.map

package/lib/histories/contents/AgenticaUserMessageAudioContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgenticaUserMessageAudioContent.js","sourceRoot":"","sources":["../../../src/histories/contents/AgenticaUserMessageAudioContent.ts"],"names":[],"mappings":""}

package/lib/histories/contents/AgenticaUserMessageContent.d.ts

@@ -0,0 +1,14 @@
+import type { AgenticaUserMessageAudioContent } from "./AgenticaUserMessageAudioContent";
+import type { AgenticaUserMessageFileContent } from "./AgenticaUserMessageFileContent";
+import type { AgenticaUserMessageImageContent } from "./AgenticaUserMessageImageContent";
+import type { AgenticaUserMessageTextContent } from "./AgenticaUserMessageTextContent";
+export type AgenticaUserMessageContent = AgenticaUserMessageAudioContent | AgenticaUserMessageFileContent | AgenticaUserMessageImageContent | AgenticaUserMessageTextContent;
+export declare namespace AgenticaUserMessageContent {
+    type Type = AgenticaUserMessageContent["type"];
+    interface Mapper {
+        audio: AgenticaUserMessageAudioContent;
+        file: AgenticaUserMessageFileContent;
+        image: AgenticaUserMessageImageContent;
+        text: AgenticaUserMessageTextContent;
+    }
+}

package/lib/histories/{AgenticaTextHistory.js → contents/AgenticaUserMessageContent.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=AgenticaTextHistory.js.map
+//# sourceMappingURL=AgenticaUserMessageContent.js.map

package/lib/histories/contents/AgenticaUserMessageContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgenticaUserMessageContent.js","sourceRoot":"","sources":["../../../src/histories/contents/AgenticaUserMessageContent.ts"],"names":[],"mappings":""}

package/lib/histories/contents/AgenticaUserMessageContentBase.d.ts

@@ -0,0 +1,6 @@
+export interface AgenticaUserMessageContentBase<Type extends string> {
+    /**
+     * Discriminator for the type of content.
+     */
+    type: Type;
+}

package/lib/histories/contents/AgenticaUserMessageContentBase.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AgenticaUserMessageContentBase.js.map

package/lib/histories/contents/AgenticaUserMessageContentBase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgenticaUserMessageContentBase.js","sourceRoot":"","sources":["../../../src/histories/contents/AgenticaUserMessageContentBase.ts"],"names":[],"mappings":""}

package/lib/histories/contents/AgenticaUserMessageFileContent.d.ts

@@ -0,0 +1,26 @@
+import type { AgenticaUserMessageContentBase } from "./AgenticaUserMessageContentBase";
+/**
+ * File content by user.
+ *
+ * @reference https://platform.openai.com/docs/api-reference/uploads/create
+ * @author SunRabbit
+ */
+export interface AgenticaUserMessageFileContent extends AgenticaUserMessageContentBase<"file"> {
+    /**
+     * Reference to the pre-uploaded file or the data itself.
+     *
+     * @todo Properly define independent interface
+     */
+    file: AgenticaUserMessageFileContent.IReference | AgenticaUserMessageFileContent.IData;
+}
+export declare namespace AgenticaUserMessageFileContent {
+    interface IReference {
+        type: "reference";
+        id: string;
+    }
+    interface IData {
+        type: "data";
+        name: string;
+        data: string;
+    }
+}

package/lib/histories/contents/AgenticaUserMessageFileContent.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AgenticaUserMessageFileContent.js.map

package/lib/histories/contents/AgenticaUserMessageFileContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgenticaUserMessageFileContent.js","sourceRoot":"","sources":["../../../src/histories/contents/AgenticaUserMessageFileContent.ts"],"names":[],"mappings":""}

package/lib/histories/contents/AgenticaUserMessageImageContent.d.ts

@@ -0,0 +1,20 @@
+import type { tags } from "typia";
+import type { AgenticaUserMessageContentBase } from "./AgenticaUserMessageContentBase";
+/**
+ * Image content by user.
+ *
+ * @reference https://platform.openai.com/docs/guides/vision
+ * @author SunRabbit
+ */
+export interface AgenticaUserMessageImageContent extends AgenticaUserMessageContentBase<"image"> {
+    /**
+     * Image URL.
+     */
+    url: string & tags.Format<"url">;
+    /**
+     * Specifies the detail level of the image.
+     *
+     * @reference https://platform.openai.com/docs/guides/vision#low-or-high-fidelity-image-understanding
+     */
+    detail?: "auto" | "high" | "low" | undefined;
+}

package/lib/histories/contents/AgenticaUserMessageImageContent.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AgenticaUserMessageImageContent.js.map

package/lib/histories/contents/AgenticaUserMessageImageContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgenticaUserMessageImageContent.js","sourceRoot":"","sources":["../../../src/histories/contents/AgenticaUserMessageImageContent.ts"],"names":[],"mappings":""}

package/lib/histories/contents/AgenticaUserMessageTextContent.d.ts

@@ -0,0 +1,14 @@
+import type { AgenticaUserMessageContentBase } from "./AgenticaUserMessageContentBase";
+/**
+ * Text content by user.
+ *
+ * @reference https://platform.openai.com/docs/guides/text-generation
+ * @author Samchon
+ * @author SunRabbit
+ */
+export interface AgenticaUserMessageTextContent extends AgenticaUserMessageContentBase<"text"> {
+    /**
+     * The text content.
+     */
+    text: string;
+}

package/lib/histories/contents/AgenticaUserMessageTextContent.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AgenticaUserMessageTextContent.js.map

package/lib/histories/contents/AgenticaUserMessageTextContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgenticaUserMessageTextContent.js","sourceRoot":"","sources":["../../../src/histories/contents/AgenticaUserMessageTextContent.ts"],"names":[],"mappings":""}

package/lib/histories/contents/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./AgenticaUserMessageAudioContent";
+export * from "./AgenticaUserMessageContent";
+export * from "./AgenticaUserMessageFileContent";
+export * from "./AgenticaUserMessageImageContent";
+export * from "./AgenticaUserMessageTextContent";

package/lib/histories/contents/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AgenticaUserMessageAudioContent"), exports);
+__exportStar(require("./AgenticaUserMessageContent"), exports);
+__exportStar(require("./AgenticaUserMessageFileContent"), exports);
+__exportStar(require("./AgenticaUserMessageImageContent"), exports);
+__exportStar(require("./AgenticaUserMessageTextContent"), exports);
+//# sourceMappingURL=index.js.map

package/lib/histories/contents/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/histories/contents/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oEAAkD;AAClD,+DAA6C;AAC7C,mEAAiD;AACjD,oEAAkD;AAClD,mEAAiD"}

package/lib/histories/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./AgenticaAssistantMessageHistory";
+export * from "./AgenticaCancelHistory";
+export * from "./AgenticaDescribeHistory";
+export * from "./AgenticaExecuteHistory";
+export * from "./AgenticaHistory";
+export * from "./AgenticaSelectHistory";
+export * from "./AgenticaSystemMessageHistory";
+export * from "./AgenticaUserMessageHistory";
+export * from "./contents";
+export * from "./MicroAgenticaHistory";

package/lib/histories/index.js

@@ -0,0 +1,27 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AgenticaAssistantMessageHistory"), exports);
+__exportStar(require("./AgenticaCancelHistory"), exports);
+__exportStar(require("./AgenticaDescribeHistory"), exports);
+__exportStar(require("./AgenticaExecuteHistory"), exports);
+__exportStar(require("./AgenticaHistory"), exports);
+__exportStar(require("./AgenticaSelectHistory"), exports);
+__exportStar(require("./AgenticaSystemMessageHistory"), exports);
+__exportStar(require("./AgenticaUserMessageHistory"), exports);
+__exportStar(require("./contents"), exports);
+__exportStar(require("./MicroAgenticaHistory"), exports);
+//# sourceMappingURL=index.js.map

package/lib/histories/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/histories/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oEAAkD;AAClD,0DAAwC;AACxC,4DAA0C;AAC1C,2DAAyC;AACzC,oDAAkC;AAClC,0DAAwC;AACxC,iEAA+C;AAC/C,+DAA6C;AAC7C,6CAA2B;AAC3B,yDAAuC"}

package/lib/index.d.ts

@@ -1,49 +1,10 @@
 export * from "./Agentica";
-export * from "./context/AgenticaContext";
-export * from "./context/AgenticaOperation";
-export * from "./context/AgenticaOperationCollection";
-export * from "./context/AgenticaOperationSelection";
-export * from "./context/AgenticaTokenUsage";
-export * from "./events/AgenticaCallEvent";
-export * from "./events/AgenticaCancelEvent";
-export * from "./events/AgenticaDescribeEvent";
-export * from "./events/AgenticaEvent";
-export * from "./events/AgenticaEventSource";
-export * from "./events/AgenticaExecuteEvent";
-export * from "./events/AgenticaRequestEvent";
-export * from "./events/AgenticaResponseEvent";
-export * from "./events/AgenticaSelectEvent";
-export * from "./events/AgenticaTextEvent";
-export * from "./events/AgenticaValidateEvent";
-export * from "./events/MicroAgenticaEvent";
+export * from "./context";
+export * from "./events";
 export * as factory from "./factory";
-export * from "./functional/assertHttpController";
-export * from "./functional/assertHttpLlmApplication";
-export * from "./functional/assertMcpController";
-export * from "./functional/validateHttpController";
-export * from "./functional/validateHttpLlmApplication";
-export * from "./functional/validateMcpController";
-export * from "./histories/AgenticaCancelHistory";
-export * from "./histories/AgenticaDescribeHistory";
-export * from "./histories/AgenticaExecuteHistory";
-export * from "./histories/AgenticaHistory";
-export * from "./histories/AgenticaSelectHistory";
-export * from "./histories/AgenticaTextHistory";
-export * from "./histories/MicroAgenticaHistory";
-export * from "./json/IAgenticaEventJson";
-export * from "./json/IAgenticaHistoryJson";
-export * from "./json/IAgenticaOperationJson";
-export * from "./json/IAgenticaOperationSelectionJson";
-export * from "./json/IAgenticaTokenUsageJson";
-export * from "./json/IMicroAgenticaEventJson";
-export * from "./json/IMicroAgenticaHistoryJson";
+export * from "./functional";
+export * from "./histories";
+export * from "./json";
 export * from "./MicroAgentica";
 export * as orchestrate from "./orchestrate";
-export * from "./structures/IAgenticaConfig";
-export * from "./structures/IAgenticaController";
-export * from "./structures/IAgenticaExecutor";
-export * from "./structures/IAgenticaProps";
-export * from "./structures/IAgenticaSystemPrompt";
-export * from "./structures/IAgenticaVendor";
-export * from "./structures/IMicroAgenticaConfig";
-export * from "./structures/IMicroAgenticaProps";
+export * from "./structures";