@agentica/benchmark 0.8.3 → 0.9.0

package/src/AgenticaCallBenchmark.ts

@@ -1,5 +1,6 @@
 import { Agentica } from "@agentica/core";
 import { AgenticaTokenUsageAggregator } from "@agentica/core/src/internal/AgenticaTokenUsageAggregator";
+import { ILlmSchema } from "@samchon/openapi";
 import { Semaphore } from "tstl";
 import { tags } from "typia";
 
@@ -29,18 +30,18 @@ import { IAgenticaCallBenchmarkScenario } from "./structures/IAgenticaCallBenchm
  *
  * @author Samchon
  */
-export class AgenticaCallBenchmark {
-  private agent_: Agentica;
-  private scenarios_: IAgenticaCallBenchmarkScenario[];
+export class AgenticaCallBenchmark<Model extends ILlmSchema.Model> {
+  private agent_: Agentica<Model>;
+  private scenarios_: IAgenticaCallBenchmarkScenario<Model>[];
   private config_: AgenticaCallBenchmark.IConfig;
-  private result_: IAgenticaCallBenchmarkResult | null;
+  private result_: IAgenticaCallBenchmarkResult<Model> | null;
 
   /**
    * Initializer Constructor.
    *
    * @param props Properties of the selection benchmark
    */
-  public constructor(props: AgenticaCallBenchmark.IProps) {
+  public constructor(props: AgenticaCallBenchmark.IProps<Model>) {
     this.agent_ = props.agent;
     this.scenarios_ = props.scenarios.slice();
     this.config_ = {
@@ -68,22 +69,24 @@ export class AgenticaCallBenchmark {
    * @returns Results of the function calling benchmark
    */
   public async execute(
-    listener?: (event: IAgenticaCallBenchmarkEvent) => void,
-  ): Promise<IAgenticaCallBenchmarkResult> {
+    listener?: (event: IAgenticaCallBenchmarkEvent<Model>) => void,
+  ): Promise<IAgenticaCallBenchmarkResult<Model>> {
     const started_at: Date = new Date();
     const semaphore: Semaphore = new Semaphore(this.config_.simultaneous);
-    const experiments: IAgenticaCallBenchmarkResult.IExperiment[] =
+    const experiments: IAgenticaCallBenchmarkResult.IExperiment<Model>[] =
       await Promise.all(
         this.scenarios_.map(async (scenario) => {
-          const events: IAgenticaCallBenchmarkEvent[] = await Promise.all(
-            new Array(this.config_.repeat).fill(0).map(async () => {
-              await semaphore.acquire();
-              const e: IAgenticaCallBenchmarkEvent = await this.step(scenario);
-              await semaphore.release();
-              if (listener !== undefined) listener(e);
-              return e;
-            }),
-          );
+          const events: IAgenticaCallBenchmarkEvent<Model>[] =
+            await Promise.all(
+              new Array(this.config_.repeat).fill(0).map(async () => {
+                await semaphore.acquire();
+                const e: IAgenticaCallBenchmarkEvent<Model> =
+                  await this.step(scenario);
+                await semaphore.release();
+                if (listener !== undefined) listener(e);
+                return e;
+              }),
+            );
           return {
             scenario,
             events,
@@ -135,9 +138,9 @@ export class AgenticaCallBenchmark {
   }
 
   private async step(
-    scenario: IAgenticaCallBenchmarkScenario,
-  ): Promise<IAgenticaCallBenchmarkEvent> {
-    const agent: Agentica = this.agent_.clone();
+    scenario: IAgenticaCallBenchmarkScenario<Model>,
+  ): Promise<IAgenticaCallBenchmarkEvent<Model>> {
+    const agent: Agentica<Model> = this.agent_.clone();
     const started_at: Date = new Date();
     const success = () =>
       AgenticaBenchmarkPredicator.success({
@@ -147,7 +150,7 @@ export class AgenticaCallBenchmark {
           .filter((p) => p.type === "execute"),
         strict: false,
       });
-    const out = (): IAgenticaCallBenchmarkEvent => {
+    const out = (): IAgenticaCallBenchmarkEvent<Model> => {
       const select = AgenticaBenchmarkPredicator.success({
         expected: scenario.expected,
         operations: agent
@@ -167,7 +170,7 @@ export class AgenticaCallBenchmark {
         usage: agent.getTokenUsage(),
         started_at,
         completed_at: new Date(),
-      } satisfies IAgenticaCallBenchmarkEvent.IFailure;
+      } satisfies IAgenticaCallBenchmarkEvent.IFailure<Model>;
     };
 
     try {
@@ -199,16 +202,16 @@ export namespace AgenticaCallBenchmark {
   /**
    * Properties of the {@link AgenticaCallBenchmark} constructor.
    */
-  export interface IProps {
+  export interface IProps<Model extends ILlmSchema.Model> {
     /**
      * AI agent instance.
      */
-    agent: Agentica;
+    agent: Agentica<Model>;
 
     /**
      * List of scenarios what you expect.
      */
-    scenarios: IAgenticaCallBenchmarkScenario[];
+    scenarios: IAgenticaCallBenchmarkScenario<Model>[];
 
     /**
      * Configuration for the benchmark.

package/src/AgenticaSelectBenchmark.ts

@@ -7,6 +7,7 @@ import {
 } from "@agentica/core";
 import { ChatGptSelectFunctionAgent } from "@agentica/core/src/chatgpt/ChatGptSelectFunctionAgent";
 import { AgenticaTokenUsageAggregator } from "@agentica/core/src/internal/AgenticaTokenUsageAggregator";
+import { ILlmSchema } from "@samchon/openapi";
 import { Semaphore } from "tstl";
 import { tags } from "typia";
 
@@ -33,19 +34,19 @@ import { IAgenticaSelectBenchmarkScenario } from "./structures/IAgenticaSelectBe
  *
  * @author Samchon
  */
-export class AgenticaSelectBenchmark {
-  private agent_: Agentica;
-  private scenarios_: IAgenticaSelectBenchmarkScenario[];
+export class AgenticaSelectBenchmark<Model extends ILlmSchema.Model> {
+  private agent_: Agentica<Model>;
+  private scenarios_: IAgenticaSelectBenchmarkScenario<Model>[];
   private config_: AgenticaSelectBenchmark.IConfig;
-  private histories_: IAgenticaPrompt[];
-  private result_: IAgenticaSelectBenchmarkResult | null;
+  private histories_: IAgenticaPrompt<Model>[];
+  private result_: IAgenticaSelectBenchmarkResult<Model> | null;
 
   /**
    * Initializer Constructor.
    *
    * @param props Properties of the selection benchmark
    */
-  public constructor(props: AgenticaSelectBenchmark.IProps) {
+  public constructor(props: AgenticaSelectBenchmark.IProps<Model>) {
     this.agent_ = props.agent;
     this.scenarios_ = props.scenarios.slice();
     this.config_ = {
@@ -73,23 +74,24 @@ export class AgenticaSelectBenchmark {
    * @returns Results of the function selection benchmark
    */
   public async execute(
-    listener?: (event: IAgenticaSelectBenchmarkEvent) => void,
-  ): Promise<IAgenticaSelectBenchmarkResult> {
+    listener?: (event: IAgenticaSelectBenchmarkEvent<Model>) => void,
+  ): Promise<IAgenticaSelectBenchmarkResult<Model>> {
     const started_at: Date = new Date();
     const semaphore: Semaphore = new Semaphore(this.config_.simultaneous);
-    const experiments: IAgenticaSelectBenchmarkResult.IExperiment[] =
+    const experiments: IAgenticaSelectBenchmarkResult.IExperiment<Model>[] =
       await Promise.all(
         this.scenarios_.map(async (scenario) => {
-          const events: IAgenticaSelectBenchmarkEvent[] = await Promise.all(
-            new Array(this.config_.repeat).fill(0).map(async () => {
-              await semaphore.acquire();
-              const e: IAgenticaSelectBenchmarkEvent =
-                await this.step(scenario);
-              await semaphore.release();
-              if (listener !== undefined) listener(e);
-              return e;
-            }),
-          );
+          const events: IAgenticaSelectBenchmarkEvent<Model>[] =
+            await Promise.all(
+              new Array(this.config_.repeat).fill(0).map(async () => {
+                await semaphore.acquire();
+                const e: IAgenticaSelectBenchmarkEvent<Model> =
+                  await this.step(scenario);
+                await semaphore.release();
+                if (listener !== undefined) listener(e);
+                return e;
+              }),
+            );
           return {
             scenario,
             events,
@@ -142,12 +144,12 @@ export class AgenticaSelectBenchmark {
   }
 
   private async step(
-    scenario: IAgenticaSelectBenchmarkScenario,
-  ): Promise<IAgenticaSelectBenchmarkEvent> {
+    scenario: IAgenticaSelectBenchmarkScenario<Model>,
+  ): Promise<IAgenticaSelectBenchmarkEvent<Model>> {
     const started_at: Date = new Date();
     try {
       const usage: IAgenticaTokenUsage = AgenticaTokenUsageAggregator.zero();
-      const prompts: IAgenticaPrompt[] =
+      const prompts: IAgenticaPrompt<Model>[] =
         await ChatGptSelectFunctionAgent.execute({
           ...this.agent_.getContext({
             prompt: {
@@ -161,8 +163,8 @@ export class AgenticaSelectBenchmark {
           stack: [],
           ready: () => true,
           dispatch: async () => {},
-        } satisfies IAgenticaContext);
-      const selected: IAgenticaOperationSelection[] = prompts
+        } satisfies IAgenticaContext<Model>);
+      const selected: IAgenticaOperationSelection<Model>[] = prompts
         .filter((p) => p.type === "select")
         .map((p) => p.operations)
         .flat();
@@ -185,8 +187,8 @@ export class AgenticaSelectBenchmark {
         started_at,
         completed_at: new Date(),
       } satisfies
-        | IAgenticaSelectBenchmarkEvent.ISuccess
-        | IAgenticaSelectBenchmarkEvent.IFailure;
+        | IAgenticaSelectBenchmarkEvent.ISuccess<Model>
+        | IAgenticaSelectBenchmarkEvent.IFailure<Model>;
     } catch (error) {
       return {
         type: "error",
@@ -194,7 +196,7 @@ export class AgenticaSelectBenchmark {
         error,
         started_at,
         completed_at: new Date(),
-      } satisfies IAgenticaSelectBenchmarkEvent.IError;
+      } satisfies IAgenticaSelectBenchmarkEvent.IError<Model>;
     }
   }
 }
@@ -202,16 +204,16 @@ export namespace AgenticaSelectBenchmark {
   /**
    * Properties of the {@link AgenticaSelectBenchmark} constructor.
    */
-  export interface IProps {
+  export interface IProps<Model extends ILlmSchema.Model> {
     /**
      * AI agent instance.
      */
-    agent: Agentica;
+    agent: Agentica<Model>;
 
     /**
      * List of scenarios what you expect.
      */
-    scenarios: IAgenticaSelectBenchmarkScenario[];
+    scenarios: IAgenticaSelectBenchmarkScenario<Model>[];
 
     /**
      * Configuration for the benchmark.

package/src/internal/AgenticaBenchmarkPredicator.ts

@@ -1,13 +1,17 @@
 import { Agentica, IAgenticaOperation, IAgenticaPrompt } from "@agentica/core";
-import { ILlmFunction } from "@samchon/openapi";
+import { ILlmFunction, ILlmSchema } from "@samchon/openapi";
 import OpenAI from "openai";
 import typia from "typia";
 
 import { IAgenticaBenchmarkExpected } from "../structures/IAgenticaBenchmarkExpected";
 
 export namespace AgenticaBenchmarkPredicator {
-  export const isNext = async (agent: Agentica): Promise<string | null> => {
-    const last: IAgenticaPrompt | undefined = agent.getPromptHistories().at(-1);
+  export const isNext = async <Model extends ILlmSchema.Model>(
+    agent: Agentica<Model>,
+  ): Promise<string | null> => {
+    const last: IAgenticaPrompt<Model> | undefined = agent
+      .getPromptHistories()
+      .at(-1);
     if (last?.type !== "text" || last.role !== "assistant") return null;
 
     const consent: ILlmFunction<"chatgpt"> = typia.llm.application<
@@ -69,18 +73,20 @@ export namespace AgenticaBenchmarkPredicator {
    * @returns `true` if the called operations match the expected operations,
    * otherwise `false`.
    */
-  export const success = (props: {
+  export const success = <Model extends ILlmSchema.Model>(props: {
     /**
      * Expected operations to be called.
      *
      * For 'allOf' within an 'array', the next expected element starts checking from the element that follows the last called element in 'allOf'.
      */
-    expected: IAgenticaBenchmarkExpected;
+    expected: IAgenticaBenchmarkExpected<Model>;
 
     /**
      * Specified operations.
      */
-    operations: Array<IAgenticaOperation | IAgenticaPrompt.IExecute>;
+    operations: Array<
+      IAgenticaOperation<Model> | IAgenticaPrompt.IExecute<Model>
+    >;
 
     /**
      * If it's `false`, check the array and let it go even if there's something wrong between them.
@@ -90,8 +96,8 @@ export namespace AgenticaBenchmarkPredicator {
     strict?: boolean;
   }): boolean => successInner(props).result;
 
-  const successInner = (
-    props: Parameters<typeof success>[0],
+  const successInner = <Model extends ILlmSchema.Model>(
+    props: Parameters<typeof success<Model>>[0],
   ):
     | {
         result: true;
@@ -101,8 +107,10 @@ export namespace AgenticaBenchmarkPredicator {
         result: false;
       } => {
     const call = (
-      expected: IAgenticaBenchmarkExpected,
-      overrideOperations?: Array<IAgenticaOperation | IAgenticaPrompt.IExecute>,
+      expected: IAgenticaBenchmarkExpected<Model>,
+      overrideOperations?: Array<
+        IAgenticaOperation<Model> | IAgenticaPrompt.IExecute<Model>
+      >,
     ) =>
       successInner({
         expected,

package/src/internal/AgenticaBenchmarkUtil.ts

@@ -1,3 +1,5 @@
+import { ILlmSchema } from "@samchon/openapi";
+
 import { IAgenticaBenchmarkExpected } from "../structures/IAgenticaBenchmarkExpected";
 
 export namespace AgenticaBenchmarkUtil {
@@ -12,7 +14,9 @@ export namespace AgenticaBenchmarkUtil {
     return error;
   };
 
-  export const expectedToJson = (expected: IAgenticaBenchmarkExpected): any => {
+  export const expectedToJson = <Model extends ILlmSchema.Model>(
+    expected: IAgenticaBenchmarkExpected<Model>,
+  ): any => {
     if (expected.type === "standalone")
       return {
         type: expected.type,

package/src/internal/AgenticaCallBenchmarkReporter.ts

@@ -1,4 +1,5 @@
 import { IAgenticaTokenUsage } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
 
 import { IAgenticaCallBenchmarkEvent } from "../structures/IAgenticaCallBenchmarkEvent";
 import { IAgenticaCallBenchmarkResult } from "../structures/IAgenticaCallBenchmarkResult";
@@ -7,11 +8,11 @@ import { AgenticaBenchmarkUtil } from "./AgenticaBenchmarkUtil";
 import { AgenticaPromptReporter } from "./AgenticaPromptReporter";
 
 export namespace AgenticaCallBenchmarkReporter {
-  export const markdown = (
-    result: IAgenticaCallBenchmarkResult,
+  export const markdown = <Model extends ILlmSchema.Model>(
+    result: IAgenticaCallBenchmarkResult<Model>,
   ): Record<string, string> =>
     Object.fromEntries([
-      ["./README.md", writeIndex(result)],
+      ["./README.md", writeIndex<Model>(result)],
       ...result.experiments
         .map((exp) => [
           [`./${exp.scenario.name}/README.md`, writeExperimentIndex(exp)],
@@ -23,8 +24,10 @@ export namespace AgenticaCallBenchmarkReporter {
         .flat(),
     ]);
 
-  const writeIndex = (result: IAgenticaCallBenchmarkResult): string => {
-    const events: IAgenticaCallBenchmarkEvent[] = result.experiments
+  const writeIndex = <Model extends ILlmSchema.Model>(
+    result: IAgenticaCallBenchmarkResult<Model>,
+  ): string => {
+    const events: IAgenticaCallBenchmarkEvent<Model>[] = result.experiments
       .map((r) => r.events)
       .flat();
     const average: number =
@@ -73,8 +76,8 @@ export namespace AgenticaCallBenchmarkReporter {
     ].join("\n");
   };
 
-  const writeExperimentIndex = (
-    exp: IAgenticaCallBenchmarkResult.IExperiment,
+  const writeExperimentIndex = <Model extends ILlmSchema.Model>(
+    exp: IAgenticaCallBenchmarkResult.IExperiment<Model>,
   ): string => {
     return [
       `# ${exp.scenario.name}`,
@@ -114,8 +117,8 @@ export namespace AgenticaCallBenchmarkReporter {
     ].join("\n");
   };
 
-  const writeExperimentEvent = (
-    event: IAgenticaCallBenchmarkEvent,
+  const writeExperimentEvent = <Model extends ILlmSchema.Model>(
+    event: IAgenticaCallBenchmarkEvent<Model>,
     index: number,
   ): string => {
     return [
@@ -165,9 +168,9 @@ export namespace AgenticaCallBenchmarkReporter {
     ].join("\n");
   };
 
-  const drawStatus = (
-    events: IAgenticaCallBenchmarkEvent[],
-    success: (e: IAgenticaCallBenchmarkEvent) => boolean,
+  const drawStatus = <Model extends ILlmSchema.Model>(
+    events: IAgenticaCallBenchmarkEvent<Model>[],
+    success: (e: IAgenticaCallBenchmarkEvent<Model>) => boolean,
   ): string => {
     const count: number = Math.floor(
       (events.filter(success).length / events.length) * 10,

package/src/internal/AgenticaPromptReporter.ts

@@ -1,7 +1,10 @@
 import { IAgenticaPrompt } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
 
 export namespace AgenticaPromptReporter {
-  export const markdown = (p: IAgenticaPrompt): string => {
+  export const markdown = <Model extends ILlmSchema.Model>(
+    p: IAgenticaPrompt<Model>,
+  ): string => {
     if (p.type === "text")
       return [`### Text (${p.role})`, p.text, ""].join("\n");
     else if (p.type === "select" || p.type === "cancel")

package/src/internal/AgenticaSelectBenchmarkReporter.ts

@@ -1,4 +1,5 @@
 import { IAgenticaTokenUsage } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
 
 import { IAgenticaSelectBenchmarkEvent } from "../structures/IAgenticaSelectBenchmarkEvent";
 import { IAgenticaSelectBenchmarkResult } from "../structures/IAgenticaSelectBenchmarkResult";
@@ -9,8 +10,8 @@ import { AgenticaBenchmarkUtil } from "./AgenticaBenchmarkUtil";
  * @internal
  */
 export namespace AgenticaSelectBenchmarkReporter {
-  export const markdown = (
-    result: IAgenticaSelectBenchmarkResult,
+  export const markdown = <Model extends ILlmSchema.Model>(
+    result: IAgenticaSelectBenchmarkResult<Model>,
   ): Record<string, string> =>
     Object.fromEntries([
       ["./README.md", writeIndex(result)],
@@ -25,8 +26,10 @@ export namespace AgenticaSelectBenchmarkReporter {
         .flat(),
     ]);
 
-  const writeIndex = (result: IAgenticaSelectBenchmarkResult): string => {
-    const events: IAgenticaSelectBenchmarkEvent[] = result.experiments
+  const writeIndex = <Model extends ILlmSchema.Model>(
+    result: IAgenticaSelectBenchmarkResult<Model>,
+  ): string => {
+    const events: IAgenticaSelectBenchmarkEvent<Model>[] = result.experiments
       .map((r) => r.events)
       .flat();
     const average: number =
@@ -84,8 +87,8 @@ export namespace AgenticaSelectBenchmarkReporter {
     ].join("\n");
   };
 
-  const writeExperimentIndex = (
-    exp: IAgenticaSelectBenchmarkResult.IExperiment,
+  const writeExperimentIndex = <Model extends ILlmSchema.Model>(
+    exp: IAgenticaSelectBenchmarkResult.IExperiment<Model>,
   ): string => {
     const aggregate: IAgenticaTokenUsage.IComponent = exp.usage.aggregate;
     return [
@@ -141,8 +144,8 @@ export namespace AgenticaSelectBenchmarkReporter {
     ].join("\n");
   };
 
-  const writeExperimentEvent = (
-    event: IAgenticaSelectBenchmarkEvent,
+  const writeExperimentEvent = <Model extends ILlmSchema.Model>(
+    event: IAgenticaSelectBenchmarkEvent<Model>,
     index: number,
   ): string => {
     return [

package/src/structures/IAgenticaBenchmarkExpected.ts

@@ -1,4 +1,5 @@
 import { IAgenticaOperation } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
 
 /**
  * Expected operation determinant.
@@ -12,47 +13,56 @@ import { IAgenticaOperation } from "@agentica/core";
  *
  * @author Samchon
  */
-export type IAgenticaBenchmarkExpected =
-  | IAgenticaBenchmarkExpected.IAllOf
-  | IAgenticaBenchmarkExpected.IAnyOf
-  | IAgenticaBenchmarkExpected.IArray
-  | IAgenticaBenchmarkExpected.IStandalone;
+export type IAgenticaBenchmarkExpected<Model extends ILlmSchema.Model> =
+  | IAgenticaBenchmarkExpected.IAllOf<Model>
+  | IAgenticaBenchmarkExpected.IAnyOf<Model>
+  | IAgenticaBenchmarkExpected.IArray<Model>
+  | IAgenticaBenchmarkExpected.IStandalone<Model>;
 export namespace IAgenticaBenchmarkExpected {
   /**
    * All of them must meet the condition, but sequence is not important.
    */
-  export interface IAllOf {
+  export interface IAllOf<Model extends ILlmSchema.Model> {
     type: "allOf";
     allOf: Array<
-      Exclude<IAgenticaBenchmarkExpected, IAgenticaBenchmarkExpected.IAllOf>
+      Exclude<
+        IAgenticaBenchmarkExpected<Model>,
+        IAgenticaBenchmarkExpected.IAllOf<Model>
+      >
     >;
   }
 
   /**
    * At least one of them must meet the condition.
    */
-  export interface IAnyOf {
+  export interface IAnyOf<Model extends ILlmSchema.Model> {
     type: "anyOf";
     anyOf: Array<
-      Exclude<IAgenticaBenchmarkExpected, IAgenticaBenchmarkExpected.IAnyOf>
+      Exclude<
+        IAgenticaBenchmarkExpected<Model>,
+        IAgenticaBenchmarkExpected.IAnyOf<Model>
+      >
     >;
   }
 
   /**
    * All of them must meet the condition, and sequence is important.
    */
-  export interface IArray {
+  export interface IArray<Model extends ILlmSchema.Model> {
     type: "array";
     items: Array<
-      Exclude<IAgenticaBenchmarkExpected, IAgenticaBenchmarkExpected.IArray>
+      Exclude<
+        IAgenticaBenchmarkExpected<Model>,
+        IAgenticaBenchmarkExpected.IArray<Model>
+      >
     >;
   }
 
   /**
    * Standalone operation.
    */
-  export interface IStandalone {
+  export interface IStandalone<Model extends ILlmSchema.Model> {
     type: "standalone";
-    operation: IAgenticaOperation;
+    operation: IAgenticaOperation<Model>;
   }
 }

package/src/structures/IAgenticaCallBenchmarkEvent.ts

@@ -1,4 +1,5 @@
 import { IAgenticaPrompt, IAgenticaTokenUsage } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
 
 import { IAgenticaCallBenchmarkScenario } from "./IAgenticaCallBenchmarkScenario";
 
@@ -24,10 +25,10 @@ import { IAgenticaCallBenchmarkScenario } from "./IAgenticaCallBenchmarkScenario
  *
  * @author Samchon
  */
-export type IAgenticaCallBenchmarkEvent =
-  | IAgenticaCallBenchmarkEvent.ISuccess
-  | IAgenticaCallBenchmarkEvent.IFailure
-  | IAgenticaCallBenchmarkEvent.IError;
+export type IAgenticaCallBenchmarkEvent<Model extends ILlmSchema.Model> =
+  | IAgenticaCallBenchmarkEvent.ISuccess<Model>
+  | IAgenticaCallBenchmarkEvent.IFailure<Model>
+  | IAgenticaCallBenchmarkEvent.IError<Model>;
 export namespace IAgenticaCallBenchmarkEvent {
   /**
    * Success event type.
@@ -35,7 +36,8 @@ export namespace IAgenticaCallBenchmarkEvent {
    * The `success` event type represents that the benchmark
    * testing is fully meet the expected scenario.
    */
-  export interface ISuccess extends IEventBase<"success"> {
+  export interface ISuccess<Model extends ILlmSchema.Model>
+    extends IEventBase<"success", Model> {
     /**
      * Whether succeeded to function selection.
      */
@@ -54,7 +56,8 @@ export namespace IAgenticaCallBenchmarkEvent {
    * or `caller` agents have not selected or called following the
    * expected scenario in the benchmark testing.
    */
-  export interface IFailure extends IEventBase<"failure"> {
+  export interface IFailure<Model extends ILlmSchema.Model>
+    extends IEventBase<"failure", Model> {
     /**
      * Whether succeeded to function selection.
      */
@@ -66,14 +69,15 @@ export namespace IAgenticaCallBenchmarkEvent {
     call: boolean;
   }
 
-  export interface IError extends IEventBase<"error"> {
+  export interface IError<Model extends ILlmSchema.Model>
+    extends IEventBase<"error", Model> {
     /**
      * Error occurred during the benchmark.
      */
     error: unknown;
   }
 
-  interface IEventBase<Type extends string> {
+  interface IEventBase<Type extends string, Model extends ILlmSchema.Model> {
     /**
      * Discriminant type.
      */
@@ -82,14 +86,14 @@ export namespace IAgenticaCallBenchmarkEvent {
     /**
      * Expected scenario.
      */
-    scenario: IAgenticaCallBenchmarkScenario;
+    scenario: IAgenticaCallBenchmarkScenario<Model>;
 
     /**
      * Prompt histories.
      *
      * List of prompts occurred during the benchmark testing.
      */
-    prompts: IAgenticaPrompt[];
+    prompts: IAgenticaPrompt<Model>[];
 
     /**
      * Usage of the token during the benchmark.

package/src/structures/IAgenticaCallBenchmarkResult.ts

@@ -1,4 +1,5 @@
 import { IAgenticaTokenUsage } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
 
 import { IAgenticaCallBenchmarkEvent } from "./IAgenticaCallBenchmarkEvent";
 import { IAgenticaCallBenchmarkScenario } from "./IAgenticaCallBenchmarkScenario";
@@ -20,11 +21,11 @@ import { IAgenticaCallBenchmarkScenario } from "./IAgenticaCallBenchmarkScenario
  *
  * @author Samchon
  */
-export interface IAgenticaCallBenchmarkResult {
+export interface IAgenticaCallBenchmarkResult<Model extends ILlmSchema.Model> {
   /**
    * Experiments for each scenario.
    */
-  experiments: IAgenticaCallBenchmarkResult.IExperiment[];
+  experiments: IAgenticaCallBenchmarkResult.IExperiment<Model>[];
 
   /**
    * Aggregated token usage information.
@@ -45,11 +46,11 @@ export namespace IAgenticaCallBenchmarkResult {
   /**
    * Experiment result about a scenario.
    */
-  export interface IExperiment {
+  export interface IExperiment<Model extends ILlmSchema.Model> {
     /**
      * Scenario of the experiment.
      */
-    scenario: IAgenticaCallBenchmarkScenario;
+    scenario: IAgenticaCallBenchmarkScenario<Model>;
 
     /**
      * Events occurred during the benchmark in the scenario.
@@ -59,7 +60,7 @@ export namespace IAgenticaCallBenchmarkResult {
      * {@link AgenticaCallBenchmark.IConfig.repeat repeat} count.
      * And the event is one of the repeated benchmark results.
      */
-    events: IAgenticaCallBenchmarkEvent[];
+    events: IAgenticaCallBenchmarkEvent<Model>[];
 
     /**
      * LLM token usage information.