@agentica/core 0.34.2 → 0.35.0

package/src/context/AgenticaOperationCollection.ts

@@ -1,5 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaOperation } from "./AgenticaOperation";
 
 /**
@@ -11,12 +9,11 @@ import type { AgenticaOperation } from "./AgenticaOperation";
  *
  * @author Samchon
  */
-export interface AgenticaOperationCollection<Model extends ILlmSchema.Model> {
+export interface AgenticaOperationCollection {
   /**
    * List of every operations.
    */
-  array: AgenticaOperation<Model>[];
-
+  array: AgenticaOperation[];
   /**
    * Divided operations.
    *
@@ -32,14 +29,14 @@ export interface AgenticaOperationCollection<Model extends ILlmSchema.Model> {
    * Otherwise, if the {@link IAgenticaConfig.capacity} has not been
    * configured, this `divided` property would be the `undefined` value.
    */
-  divided?: AgenticaOperation<Model>[][] | undefined;
+  divided?: AgenticaOperation[][] | undefined;
 
   /**
    * Flat dictionary of operations.
    *
    * Dictionary of operations with their {@link IAgenticaOperation.name}.
    */
-  flat: Map<string, AgenticaOperation<Model>>;
+  flat: Map<string, AgenticaOperation>;
 
   /**
    * Group dictionary of operations.
@@ -48,5 +45,5 @@ export interface AgenticaOperationCollection<Model extends ILlmSchema.Model> {
    * {@link IAgenticaOperation.controller.name} and
    * {@link IAgenticaOperation.function.name}.
    */
-  group: Map<string, Map<string, AgenticaOperation<Model>>>;
+  group: Map<string, Map<string, AgenticaOperation>>;
 }

package/src/context/AgenticaOperationSelection.ts

@@ -1,11 +1,9 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { IAgenticaOperationSelectionJson } from "../json/IAgenticaOperationSelectionJson";
 
 import type { AgenticaOperation } from "./AgenticaOperation";
 
-export interface AgenticaOperationSelection<Model extends ILlmSchema.Model> {
-  operation: AgenticaOperation<Model>;
+export interface AgenticaOperationSelection {
+  operation: AgenticaOperation;
   reason: string;
   toJSON: () => IAgenticaOperationSelectionJson;
 }

package/src/context/MicroAgenticaContext.ts

@@ -1,4 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
 import type OpenAI from "openai";
 
 import type { MicroAgenticaEvent } from "../events/MicroAgenticaEvent";
@@ -29,7 +28,7 @@ import type { AgenticaOperationCollection } from "./AgenticaOperationCollection"
  *
  * @author Samchon
  */
-export interface MicroAgenticaContext<Model extends ILlmSchema.Model> {
+export interface MicroAgenticaContext {
   // ----
   // APPLICATION
   // ----
@@ -40,7 +39,7 @@ export interface MicroAgenticaContext<Model extends ILlmSchema.Model> {
    * groups composed by the divide and conquer rule for the
    * efficient operation selection if configured.
    */
-  operations: AgenticaOperationCollection<Model>;
+  operations: AgenticaOperationCollection;
 
   /**
    * Configuration of the agent.
@@ -50,7 +49,7 @@ export interface MicroAgenticaContext<Model extends ILlmSchema.Model> {
    *
    * @todo Write detaily after supporting the agent customization feature
    */
-  config: IMicroAgenticaConfig<Model> | undefined;
+  config: IMicroAgenticaConfig | undefined;
 
   // ----
   // STATES
@@ -58,7 +57,7 @@ export interface MicroAgenticaContext<Model extends ILlmSchema.Model> {
   /**
    * Prompt histories.
    */
-  histories: MicroAgenticaHistory<Model>[];
+  histories: MicroAgenticaHistory[];
 
   /**
    * Text prompt of the user.
@@ -83,7 +82,7 @@ export interface MicroAgenticaContext<Model extends ILlmSchema.Model> {
    *
    * @param event Event to deliver
    */
-  dispatch: (event: MicroAgenticaEvent<Model>) => Promise<void>;
+  dispatch: (event: MicroAgenticaEvent) => Promise<void>;
 
   /**
    * Request to the OpenAI server.

package/src/context/internal/AgenticaOperationComposer.spec.ts

@@ -1,4 +1,4 @@
-import type { IChatGptSchema, IHttpLlmFunction, ILlmFunction, IMcpLlmFunction, IValidation } from "@samchon/openapi";
+import type { IHttpLlmFunction, ILlmFunction, ILlmSchema, IMcpLlmFunction, IValidation } from "@samchon/openapi";
 
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory";
@@ -17,7 +17,7 @@ const client = new Client({
 });
 
 // test helper functions
-function createMockHttpFunction(name: string, method: "get" | "post" | "patch" | "put" | "delete", path: string): IHttpLlmFunction<any> {
+function createMockHttpFunction(name: string, method: "get" | "post" | "patch" | "put" | "delete", path: string): IHttpLlmFunction {
   return {
     name,
     method,
@@ -38,41 +38,55 @@ function createMockHttpFunction(name: string, method: "get" | "post" | "patch" |
       comment: () => "OK",
       operation: () => ({}),
     }),
-    parameters: {},
+    parameters: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+      required: [],
+      $defs: {},
+    } satisfies ILlmSchema.IParameters,
     output: {},
   };
 }
 
-function createMockHttpController(name: string, functions: IHttpLlmFunction<any>[]): IAgenticaController.IHttp<any> {
+function createMockHttpController(name: string, functions: IHttpLlmFunction[]): IAgenticaController.IHttp {
   return {
     name,
     protocol: "http",
     connection: { host: "https://example.com" },
     application: {
-      model: "chatgpt",
-      options: {},
       functions,
+      config: {
+        reference: true,
+        strict: false,
+        separate: null,
+        maxLength: 64,
+        equals: false,
+      },
       errors: [],
     },
   };
 }
 
-function createMockClassController(name: string, functions: ILlmFunction<any>[]): IAgenticaController.IClass<any> {
+function createMockClassController(name: string, functions: ILlmFunction[]): IAgenticaController.IClass {
   return {
     name,
     protocol: "class",
     application: {
-      model: "chatgpt",
-      options: {},
       functions,
+      config: {
+        reference: true,
+        strict: false,
+        separate: null,
+        validate: null,
+      },
     },
     execute: {},
   };
 }
 
-async function createMockMcpController(name: string, functions: IMcpLlmFunction<"chatgpt">[]): Promise<IAgenticaController.IMcp<"chatgpt">> {
+async function createMockMcpController(name: string, functions: IMcpLlmFunction[]): Promise<IAgenticaController.IMcp> {
   const controller = await assertMcpController({
-    model: "chatgpt",
     name,
     client,
   });
@@ -112,7 +126,13 @@ describe("a AgenticaOperationComposer", () => {
         {
           name: "function3",
           validate: () => ({ success: true, data: {} } as IValidation<unknown>),
-          parameters: {},
+          parameters: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+            required: [],
+            $defs: {},
+          } satisfies ILlmSchema.IParameters,
           output: {},
         },
       ]);
@@ -126,7 +146,7 @@ describe("a AgenticaOperationComposer", () => {
             additionalProperties: false,
             required: [],
             $defs: {},
-          } satisfies IChatGptSchema.IParameters,
+          } satisfies ILlmSchema.IParameters,
           validate: (data: unknown) => ({
             success: true,
             data,
@@ -154,7 +174,7 @@ describe("a AgenticaOperationComposer", () => {
         createMockHttpFunction("function5", "patch", "/api/function5"),
       ]);
 
-      const config: IAgenticaConfig<any> = {
+      const config: IAgenticaConfig = {
         capacity: 2,
       };
 
@@ -186,7 +206,13 @@ describe("a AgenticaOperationComposer", () => {
         {
           name: "function1",
           validate: () => ({ success: true, data: {} } as IValidation<unknown>),
-          parameters: {},
+          parameters: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+            required: [],
+            $defs: {},
+          } satisfies ILlmSchema.IParameters,
           output: {},
         },
       ]);
@@ -224,11 +250,11 @@ describe("a AgenticaOperationComposer", () => {
     });
 
     it("should throw error for unsupported protocol", () => {
-      const mockController: IAgenticaController.IHttp<any> = {
+      const mockController: IAgenticaController.IHttp = {
         name: "unsupportedController",
         protocol: "unsupported" as unknown as "http",
         connection: { host: "https://example.com" },
-        application: { } as unknown as IAgenticaController.IHttp<any>["application"],
+        application: { } as unknown as IAgenticaController.IHttp["application"],
       };
 
       expect(() => getOperations({ controllers: [mockController], naming: (func, idx) => `_${idx}_${func}` })).toThrow("Unsupported protocol: unsupported");
@@ -257,7 +283,13 @@ describe("a AgenticaOperationComposer", () => {
         {
           name: "function1",
           validate: () => ({ success: true, data: {} } as IValidation<unknown>),
-          parameters: {},
+          parameters: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+            required: [],
+            $defs: {},
+          } satisfies ILlmSchema.IParameters,
           output: {},
         },
       ]);

package/src/context/internal/AgenticaOperationComposer.ts

@@ -1,5 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { IAgenticaConfig } from "../../structures/IAgenticaConfig";
 import type { IAgenticaController } from "../../structures/IAgenticaController";
 import type { IMicroAgenticaConfig } from "../../structures/IMicroAgenticaConfig";
@@ -16,10 +14,10 @@ import { __map_take } from "../../utils/__map_take";
  *
  * @internal
  */
-export function compose<Model extends ILlmSchema.Model>(props: {
-  controllers: IAgenticaController<Model>[];
-  config?: IAgenticaConfig<Model> | IMicroAgenticaConfig<Model> | undefined;
-}): AgenticaOperationCollection<Model> {
+export function compose(props: {
+  controllers: IAgenticaController[];
+  config?: IAgenticaConfig | IMicroAgenticaConfig | undefined;
+}): AgenticaOperationCollection {
   const unique: boolean = (props.controllers.length === 1 || (() => {
     const names = props.controllers.map(
 
@@ -28,12 +26,12 @@ export function compose<Model extends ILlmSchema.Model>(props: {
     return new Set(names).size === names.length;
   })());
 
-  const array: AgenticaOperation<Model>[] = getOperations({
+  const array: AgenticaOperation[] = getOperations({
     controllers: props.controllers,
     naming: (func: string, controllerIndex: number) => unique ? func : `_${controllerIndex}_${func}`,
   });
-  const capacity: number | undefined = (props.config as IAgenticaConfig<Model>)?.capacity;
-  const divided: AgenticaOperation<Model>[][] | undefined
+  const capacity: number | undefined = (props.config as IAgenticaConfig)?.capacity;
+  const divided: AgenticaOperation[][] | undefined
       = capacity !== undefined && array.length > capacity
         ? divide({
             array,
@@ -41,8 +39,8 @@ export function compose<Model extends ILlmSchema.Model>(props: {
           })
         : undefined;
 
-  const flat: Map<string, AgenticaOperation<Model>> = new Map();
-  const group: Map<string, Map<string, AgenticaOperation<Model>>> = new Map();
+  const flat: Map<string, AgenticaOperation> = new Map();
+  const group: Map<string, Map<string, AgenticaOperation>> = new Map();
   for (const item of array) {
     flat.set(item.name, item);
     __map_take(group, item.controller.name, () => new Map()).set(
@@ -61,10 +59,10 @@ export function compose<Model extends ILlmSchema.Model>(props: {
 /**
  * @internal
  */
-export function getOperations<Model extends ILlmSchema.Model>(props: {
-  controllers: IAgenticaController<Model>[];
+export function getOperations(props: {
+  controllers: IAgenticaController[];
   naming: (func: string, controllerIndex: number) => string;
-}): AgenticaOperation<Model>[] {
+}): AgenticaOperation[] {
   return props.controllers.flatMap((controller, idx) => {
     switch (controller.protocol) {
       case "http":{
@@ -84,11 +82,11 @@ export function getOperations<Model extends ILlmSchema.Model>(props: {
 /**
  * @internal
  */
-export function toHttpOperations<Model extends ILlmSchema.Model>(props: {
-  controller: IAgenticaController.IHttp<Model>;
+export function toHttpOperations(props: {
+  controller: IAgenticaController.IHttp;
   index: number;
   naming: (func: string, controllerIndex: number) => string;
-}): AgenticaOperation<Model>[] {
+}): AgenticaOperation[] {
   return props.controller.application.functions.map(func => ({
     protocol: "http",
     controller: props.controller,
@@ -106,11 +104,11 @@ export function toHttpOperations<Model extends ILlmSchema.Model>(props: {
 /**
  * @internal
  */
-export function toClassOperations<Model extends ILlmSchema.Model>(props: {
-  controller: IAgenticaController.IClass<Model>;
+export function toClassOperations(props: {
+  controller: IAgenticaController.IClass;
   index: number;
   naming: (func: string, controllerIndex: number) => string;
-}): AgenticaOperation<Model>[] {
+}): AgenticaOperation[] {
   return props.controller.application.functions.map(func => ({
     protocol: "class",
     controller: props.controller,
@@ -128,11 +126,11 @@ export function toClassOperations<Model extends ILlmSchema.Model>(props: {
 /**
  * @internal
  */
-export function toMcpOperations<Model extends ILlmSchema.Model>(props: {
-  controller: IAgenticaController.IMcp<Model>;
+export function toMcpOperations(props: {
+  controller: IAgenticaController.IMcp;
   index: number;
   naming: (func: string, controllerIndex: number) => string;
-}): AgenticaOperation<Model>[] {
+}): AgenticaOperation[] {
   return props.controller.application.functions.map(func => ({
     protocol: "mcp",
     controller: props.controller,

package/src/context/internal/__IChatInitialApplication.ts

@@ -11,5 +11,5 @@ export interface __IChatInitialApplication {
    * Also, user just wants to list up every remote API functions that can be
    * called from the backend server, utilize this function too.
    */
-  getApiFunctions: (props: object) => Promise<Array<IHttpLlmFunction<"chatgpt">>>;
+  getApiFunctions: (props: object) => Promise<Array<IHttpLlmFunction>>;
 }

package/src/context/internal/isAgenticaContext.ts

@@ -1,13 +1,11 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaContext } from "../AgenticaContext";
 import type { MicroAgenticaContext } from "../MicroAgenticaContext";
 
 /**
  * @internal
  */
-export function isAgenticaContext<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
-): ctx is AgenticaContext<Model> {
-  return typeof (ctx as AgenticaContext<Model>).initialize === "function";
+export function isAgenticaContext(
+  ctx: AgenticaContext | MicroAgenticaContext,
+): ctx is AgenticaContext {
+  return typeof (ctx as AgenticaContext).initialize === "function";
 }

package/src/events/AgenticaCallEvent.ts

@@ -1,5 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaOperation } from "../context/AgenticaOperation";
 import type { IAgenticaEventJson } from "../json/IAgenticaEventJson";
 
@@ -10,12 +8,11 @@ import type { AgenticaEventBase } from "./AgenticaEventBase";
  *
  * @author Samchon
  */
-export interface AgenticaCallEvent<Model extends ILlmSchema.Model>
-  extends AgenticaEventBase<"call"> {
+export interface AgenticaCallEvent extends AgenticaEventBase<"call"> {
   /**
    * Target operation to call.
    */
-  operation: AgenticaOperation<Model>;
+  operation: AgenticaOperation;
 
   /**
    * Arguments of the function calling.

package/src/events/AgenticaCancelEvent.ts

@@ -1,13 +1,9 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaOperationSelection } from "../context/AgenticaOperationSelection";
 import type { IAgenticaEventJson } from "../json/IAgenticaEventJson";
 
 import type { AgenticaEventBase } from "./AgenticaEventBase";
 
-export interface AgenticaCancelEvent<
-  Model extends ILlmSchema.Model,
-> extends AgenticaEventBase<"cancel"> {
-  selection: AgenticaOperationSelection<Model>;
+export interface AgenticaCancelEvent extends AgenticaEventBase<"cancel"> {
+  selection: AgenticaOperationSelection;
   toJSON: () => IAgenticaEventJson.ICancel;
 }

package/src/events/AgenticaDescribeEvent.ts

@@ -1,18 +1,14 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaDescribeHistory } from "../histories/AgenticaDescribeHistory";
 import type { AgenticaExecuteHistory } from "../histories/AgenticaExecuteHistory";
 import type { IAgenticaEventJson } from "../json/IAgenticaEventJson";
 
 import type { AgenticaEventBase } from "./AgenticaEventBase";
 
-export interface AgenticaDescribeEvent<
-  Model extends ILlmSchema.Model,
-> extends AgenticaEventBase<"describe"> {
-  executes: AgenticaExecuteHistory<Model>[];
+export interface AgenticaDescribeEvent extends AgenticaEventBase<"describe"> {
+  executes: AgenticaExecuteHistory[];
   stream: AsyncGenerator<string, undefined, undefined>;
 
   join: () => Promise<string>;
   toJSON: () => IAgenticaEventJson.IDescribe;
-  toHistory: () => AgenticaDescribeHistory<Model>;
+  toHistory: () => AgenticaDescribeHistory;
 }

package/src/events/AgenticaEvent.ts

@@ -1,5 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaAssistantMessageEvent } from "./AgenticaAssistantMessageEvent";
 import type { AgenticaCallEvent } from "./AgenticaCallEvent";
 import type { AgenticaCancelEvent } from "./AgenticaCancelEvent";
@@ -23,32 +21,32 @@ import type { AgenticaValidateEvent } from "./AgenticaValidateEvent";
  *
  * @author Samchon
  */
-export type AgenticaEvent<Model extends ILlmSchema.Model> =
+export type AgenticaEvent =
   | AgenticaUserMessageEvent
   | AgenticaAssistantMessageEvent
   | AgenticaInitializeEvent
-  | AgenticaSelectEvent<Model>
-  | AgenticaCallEvent<Model>
-  | AgenticaCancelEvent<Model>
-  | AgenticaExecuteEvent<Model>
-  | AgenticaDescribeEvent<Model>
-  | AgenticaValidateEvent<Model>
-  | AgenticaJsonParseErrorEvent<Model>
+  | AgenticaSelectEvent
+  | AgenticaCallEvent
+  | AgenticaCancelEvent
+  | AgenticaExecuteEvent
+  | AgenticaDescribeEvent
+  | AgenticaValidateEvent
+  | AgenticaJsonParseErrorEvent
   | AgenticaRequestEvent
   | AgenticaResponseEvent;
 export namespace AgenticaEvent {
-  export type Type = AgenticaEvent<any>["type"];
-  export interface Mapper<Model extends ILlmSchema.Model> {
+  export type Type = AgenticaEvent["type"];
+  export interface Mapper {
     userMessage: AgenticaUserMessageEvent;
     assistantMessage: AgenticaAssistantMessageEvent;
-    select: AgenticaSelectEvent<Model>;
+    select: AgenticaSelectEvent;
     initialize: AgenticaInitializeEvent;
-    call: AgenticaCallEvent<Model>;
-    cancel: AgenticaCancelEvent<Model>;
-    execute: AgenticaExecuteEvent<Model>;
-    describe: AgenticaDescribeEvent<Model>;
-    validate: AgenticaValidateEvent<Model>;
-    jsonParseError: AgenticaJsonParseErrorEvent<Model>;
+    call: AgenticaCallEvent;
+    cancel: AgenticaCancelEvent;
+    execute: AgenticaExecuteEvent;
+    describe: AgenticaDescribeEvent;
+    validate: AgenticaValidateEvent;
+    jsonParseError: AgenticaJsonParseErrorEvent;
     request: AgenticaRequestEvent;
     response: AgenticaResponseEvent;
   }

package/src/events/AgenticaEvent.type.ts

@@ -12,7 +12,7 @@ checks([
     Pass
   >(),
   check<
-    Exclude<AgenticaHistory.Type, "systemMessage"> extends keyof AgenticaEvent.Mapper<any> ? true : false,
+    Exclude<AgenticaHistory.Type, "systemMessage"> extends keyof AgenticaEvent.Mapper ? true : false,
     true,
     Pass
   >(),

package/src/events/AgenticaExecuteEvent.ts

@@ -1,4 +1,4 @@
-import type { IHttpResponse, ILlmSchema } from "@samchon/openapi";
+import type { IHttpResponse } from "@samchon/openapi";
 
 import type { AgenticaOperation } from "../context/AgenticaOperation";
 import type { AgenticaExecuteHistory } from "../histories/AgenticaExecuteHistory";
@@ -6,30 +6,30 @@ import type { IAgenticaEventJson } from "../json/IAgenticaEventJson";
 
 import type { AgenticaEventBase } from "./AgenticaEventBase";
 
-export type AgenticaExecuteEvent<Model extends ILlmSchema.Model> =
-  | AgenticaExecuteEvent.Class<Model>
-  | AgenticaExecuteEvent.Protocol<Model>;
+export type AgenticaExecuteEvent =
+  | AgenticaExecuteEvent.Class
+  | AgenticaExecuteEvent.Protocol;
 export namespace AgenticaExecuteEvent {
-  export interface Class<Model extends ILlmSchema.Model>
+  export interface Class
     extends Base<
       "class",
-      AgenticaOperation.Class<Model>,
-      AgenticaExecuteHistory.Class<Model>,
+      AgenticaOperation.Class,
+      AgenticaExecuteHistory.Class,
       unknown
     > {}
 
-  export interface Protocol<Model extends ILlmSchema.Model>
+  export interface Protocol
     extends Base<
       "http",
-      AgenticaOperation.Http<Model>,
-      AgenticaExecuteHistory.Http<Model>,
+      AgenticaOperation.Http,
+      AgenticaExecuteHistory.Http,
       IHttpResponse
     > {}
 
   interface Base<
     Protocol extends "http" | "class",
-    Operation extends AgenticaOperation<any>,
-    History extends AgenticaExecuteHistory<any>,
+    Operation extends AgenticaOperation,
+    History extends AgenticaExecuteHistory,
     Value,
   > extends AgenticaEventBase<"execute"> {
     protocol: Protocol;

package/src/events/AgenticaJsonParseErrorEvent.ts

@@ -1,16 +1,14 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaOperation } from "../context/AgenticaOperation";
 
 import type { AgenticaEventBase } from "./AgenticaEventBase";
 
-export interface AgenticaJsonParseErrorEvent<Model extends ILlmSchema.Model>
+export interface AgenticaJsonParseErrorEvent
   extends AgenticaEventBase<"jsonParseError"> {
   /**
    * ID of the tool calling.
    */
   call_id: string;
-  operation: AgenticaOperation<Model>;
+  operation: AgenticaOperation;
   arguments: string;
   errorMessage: string;
   life: number;

package/src/events/AgenticaSelectEvent.ts

@@ -1,15 +1,11 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaOperationSelection } from "../context/AgenticaOperationSelection";
 import type { AgenticaSelectHistory } from "../histories/AgenticaSelectHistory";
 import type { IAgenticaEventJson } from "../json/IAgenticaEventJson";
 
 import type { AgenticaEventBase } from "./AgenticaEventBase";
 
-export interface AgenticaSelectEvent<
-  Model extends ILlmSchema.Model,
-> extends AgenticaEventBase<"select"> {
-  selection: AgenticaOperationSelection<Model>;
+export interface AgenticaSelectEvent extends AgenticaEventBase<"select"> {
+  selection: AgenticaOperationSelection;
   toJSON: () => IAgenticaEventJson.ISelect;
-  toHistory: () => AgenticaSelectHistory<Model>;
+  toHistory: () => AgenticaSelectHistory;
 }

package/src/events/AgenticaValidateEvent.ts

@@ -1,4 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
 import type { IValidation } from "typia";
 
 import type { AgenticaOperation } from "../context/AgenticaOperation";
@@ -11,9 +10,7 @@ import type { AgenticaEventBase } from "./AgenticaEventBase";
  *
  * @author Samchon
  */
-export interface AgenticaValidateEvent<
-  Model extends ILlmSchema.Model,
-> extends AgenticaEventBase<"validate"> {
+export interface AgenticaValidateEvent extends AgenticaEventBase<"validate"> {
   /**
    * ID of the tool calling.
    */
@@ -22,7 +19,7 @@ export interface AgenticaValidateEvent<
   /**
    * Target operation to call.
    */
-  operation: AgenticaOperation<Model>;
+  operation: AgenticaOperation;
 
   /**
    * Validation result as a failure.