@agentica/core 0.34.2 → 0.35.0

package/src/histories/AgenticaHistory.ts

@@ -1,5 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaAssistantMessageHistory } from "./AgenticaAssistantMessageHistory";
 import type { AgenticaCancelHistory } from "./AgenticaCancelHistory";
 import type { AgenticaDescribeHistory } from "./AgenticaDescribeHistory";
@@ -8,21 +6,21 @@ import type { AgenticaSelectHistory } from "./AgenticaSelectHistory";
 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>
+export type AgenticaHistory =
+  | AgenticaCancelHistory
+  | AgenticaDescribeHistory
+  | AgenticaExecuteHistory
+  | AgenticaSelectHistory
   | AgenticaAssistantMessageHistory
   | AgenticaUserMessageHistory
   | AgenticaSystemMessageHistory;
 export namespace AgenticaHistory {
-  export type Type = AgenticaHistory<any>["type"];
-  export interface Mapper<Model extends ILlmSchema.Model> {
-    select: AgenticaSelectHistory<Model>;
-    cancel: AgenticaCancelHistory<Model>;
-    execute: AgenticaExecuteHistory<Model>;
-    describe: AgenticaDescribeHistory<Model>;
+  export type Type = AgenticaHistory["type"];
+  export interface Mapper {
+    select: AgenticaSelectHistory;
+    cancel: AgenticaCancelHistory;
+    execute: AgenticaExecuteHistory;
+    describe: AgenticaDescribeHistory;
     assistantMessage: AgenticaAssistantMessageHistory;
     systemMessage: AgenticaSystemMessageHistory;
     userMessage: AgenticaUserMessageHistory;

package/src/histories/AgenticaSelectHistory.ts

@@ -1,12 +1,8 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaOperationSelection } from "../context/AgenticaOperationSelection";
 import type { IAgenticaHistoryJson } from "../json/IAgenticaHistoryJson";
 
 import type { AgenticaHistoryBase } from "./AgenticaHistoryBase";
 
-export interface AgenticaSelectHistory<
-  Model extends ILlmSchema.Model,
-> extends AgenticaHistoryBase<"select", IAgenticaHistoryJson.ISelect> {
-  selection: AgenticaOperationSelection<Model>;
+export interface AgenticaSelectHistory extends AgenticaHistoryBase<"select", IAgenticaHistoryJson.ISelect> {
+  selection: AgenticaOperationSelection;
 }

package/src/histories/MicroAgenticaHistory.ts

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

package/src/orchestrate/call.ts

@@ -1,5 +1,4 @@
 import type {
-  IChatGptSchema,
   IHttpResponse,
   ILlmSchema,
   IValidation,
@@ -32,10 +31,10 @@ import { StreamUtil, toAsyncGenerator } from "../utils/StreamUtil";
 
 import { cancelFunctionFromContext } from "./internal/cancelFunctionFromContext";
 
-export async function call<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
-  operations: AgenticaOperation<Model>[],
-): Promise<AgenticaExecuteEvent<Model>[]> {
+export async function call(
+  ctx: AgenticaContext | MicroAgenticaContext,
+  operations: AgenticaOperation[],
+): Promise<AgenticaExecuteEvent[]> {
   const _retryFn = __get_retry(1);
   const retryFn = async (fn: (prevError?: unknown) => Promise<OpenAI.ChatCompletion>) => {
     return _retryFn(fn).catch((e) => {
@@ -74,7 +73,7 @@ export async function call<Model extends ILlmSchema.Model>(
           ? []
           : [{
             role: "system",
-            content: ctx.config?.systemPrompt?.execute?.(ctx.histories as MicroAgenticaHistory<Model>[])
+            content: ctx.config?.systemPrompt?.execute?.(ctx.histories as MicroAgenticaHistory[])
               ?? AgenticaSystemPrompt.EXECUTE,
           } satisfies OpenAI.ChatCompletionSystemMessageParam]),
       ],
@@ -96,7 +95,7 @@ export async function call<Model extends ILlmSchema.Model>(
                       required: [],
                       additionalProperties: false,
                       $defs: {},
-                    } satisfies IChatGptSchema.IParameters))
+                    } satisfies ILlmSchema.IParameters))
                   : s.function.parameters) as Record<string, any>,
             },
           }) as OpenAI.ChatCompletionTool,
@@ -134,19 +133,19 @@ export async function call<Model extends ILlmSchema.Model>(
     return [];
   }
 
-  const executes: AgenticaExecuteEvent<Model>[] = [];
+  const executes: AgenticaExecuteEvent[] = [];
 
   const retry: number = ctx.config?.retry ?? AgenticaConstant.RETRY;
   for (const choice of completion.choices) {
     for (const tc of choice.message.tool_calls ?? []) {
       if (tc.type === "function") {
-        const operation: AgenticaOperation<Model> | undefined = operations.find(
+        const operation: AgenticaOperation | undefined = operations.find(
           s => s.name === tc.function.name,
         );
         if (operation === undefined) {
           continue; // Ignore unknown tool calls
         }
-        const event: AgenticaExecuteEvent<Model> = await predicate(
+        const event: AgenticaExecuteEvent = await predicate(
           ctx,
           operation,
           tc,
@@ -156,7 +155,7 @@ export async function call<Model extends ILlmSchema.Model>(
         await ctx.dispatch(event);
         executes.push(event);
         if (isAgenticaContext(ctx)) {
-          cancelFunctionFromContext(ctx, {
+          cancelFunctionFromContext(ctx as unknown as AgenticaContext, {
             name: event.operation.name,
             reason: "completed",
           });
@@ -167,15 +166,15 @@ export async function call<Model extends ILlmSchema.Model>(
   return executes;
 }
 
-async function predicate<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
-  operation: AgenticaOperation<Model>,
+async function predicate(
+  ctx: AgenticaContext | MicroAgenticaContext,
+  operation: AgenticaOperation,
   toolCall: OpenAI.ChatCompletionMessageFunctionToolCall,
-  previousValidationErrors: AgenticaValidateEvent<Model>[],
+  previousValidationErrors: AgenticaValidateEvent[],
   life: number,
-): Promise<AgenticaExecuteEvent<Model>> {
+): Promise<AgenticaExecuteEvent> {
   // CHECK INPUT ARGUMENT
-  const call: AgenticaCallEvent<Model> | AgenticaJsonParseErrorEvent<Model>
+  const call: AgenticaCallEvent | AgenticaJsonParseErrorEvent
     = parseArguments(
       operation,
       toolCall,
@@ -189,7 +188,7 @@ async function predicate<Model extends ILlmSchema.Model>(
   // CHECK TYPE VALIDATION
   const check: IValidation<unknown> = operation.function.validate(call.arguments);
   if (check.success === false) {
-    const event: AgenticaValidateEvent<Model> = createValidateEvent({
+    const event: AgenticaValidateEvent = createValidateEvent({
       call_id: toolCall.id,
       operation,
       result: check,
@@ -212,14 +211,14 @@ async function predicate<Model extends ILlmSchema.Model>(
 /* -----------------------------------------------------------
   ERROR CORRECTORS
 ----------------------------------------------------------- */
-async function correctTypeError<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
-  callEvent: AgenticaCallEvent<Model>,
-  validateEvent: AgenticaValidateEvent<Model>,
-  previousValidationErrors: AgenticaValidateEvent<Model>[],
+async function correctTypeError(
+  ctx: AgenticaContext | MicroAgenticaContext,
+  callEvent: AgenticaCallEvent,
+  validateEvent: AgenticaValidateEvent,
+  previousValidationErrors: AgenticaValidateEvent[],
   life: number,
-): Promise<AgenticaExecuteEvent<Model>> {
-  return correctError<Model>(ctx, {
+): Promise<AgenticaExecuteEvent> {
+  return correctError(ctx, {
     giveUp: () => createExecuteEvent({
       call_id: callEvent.id,
       operation: callEvent.operation,
@@ -255,14 +254,14 @@ async function correctTypeError<Model extends ILlmSchema.Model>(
   });
 }
 
-async function correctJsonError<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
+async function correctJsonError(
+  ctx: AgenticaContext | MicroAgenticaContext,
   toolCall: OpenAI.ChatCompletionMessageFunctionToolCall,
-  parseErrorEvent: AgenticaJsonParseErrorEvent<Model>,
-  previousValidationErrors: AgenticaValidateEvent<Model>[],
+  parseErrorEvent: AgenticaJsonParseErrorEvent,
+  previousValidationErrors: AgenticaValidateEvent[],
   life: number,
-): Promise<AgenticaExecuteEvent<Model>> {
-  return correctError<Model>(ctx, {
+): Promise<AgenticaExecuteEvent> {
+  return correctError(ctx, {
     giveUp: () => createExecuteEvent({
       call_id: toolCall.id,
       operation: parseErrorEvent.operation,
@@ -291,11 +290,11 @@ async function correctJsonError<Model extends ILlmSchema.Model>(
   });
 }
 
-function parseArguments<Model extends ILlmSchema.Model>(
-  operation: AgenticaOperation<Model>,
+function parseArguments(
+  operation: AgenticaOperation,
   toolCall: OpenAI.ChatCompletionMessageFunctionToolCall,
   life: number,
-): AgenticaCallEvent<Model> | AgenticaJsonParseErrorEvent<Model> {
+): AgenticaCallEvent | AgenticaJsonParseErrorEvent {
   try {
     const data: Record<string, unknown> = JsonUtil.parse(toolCall.function.arguments);
     return createCallEvent({
@@ -315,11 +314,11 @@ function parseArguments<Model extends ILlmSchema.Model>(
   }
 }
 
-async function correctError<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
+async function correctError(
+  ctx: AgenticaContext | MicroAgenticaContext,
   props: {
-    giveUp: () => AgenticaExecuteEvent<Model>;
-    operation: AgenticaOperation<Model>;
+    giveUp: () => AgenticaExecuteEvent;
+    operation: AgenticaOperation;
     toolCall: {
       id: string;
       arguments: string;
@@ -327,9 +326,9 @@ async function correctError<Model extends ILlmSchema.Model>(
     };
     systemPrompt: string;
     life: number;
-    previousValidationErrors: AgenticaValidateEvent<Model>[];
+    previousValidationErrors: AgenticaValidateEvent[];
   },
-): Promise<AgenticaExecuteEvent<Model>> {
+): Promise<AgenticaExecuteEvent> {
   if (props.life <= 0) {
     return props.giveUp();
   }
@@ -352,7 +351,7 @@ async function correctError<Model extends ILlmSchema.Model>(
       {
         role: "system",
         content:
-        ctx.config?.systemPrompt?.execute?.(ctx.histories as MicroAgenticaHistory<Model>[])
+        ctx.config?.systemPrompt?.execute?.(ctx.histories as MicroAgenticaHistory[])
         ?? AgenticaSystemPrompt.EXECUTE,
       },
       {
@@ -399,7 +398,7 @@ async function correctError<Model extends ILlmSchema.Model>(
                   properties: {},
                   additionalProperties: false,
                   required: [],
-                } satisfies IChatGptSchema.IParameters))
+                } satisfies ILlmSchema.IParameters))
 
               : props.operation.function.parameters) as unknown as Record<string, unknown>,
         },
@@ -417,7 +416,7 @@ async function correctError<Model extends ILlmSchema.Model>(
   );
   return toolCall === undefined
     ? props.giveUp()
-    : predicate<Model>(
+    : predicate(
         ctx,
         props.operation,
         toolCall,
@@ -429,10 +428,10 @@ async function correctError<Model extends ILlmSchema.Model>(
 /* -----------------------------------------------------------
   FUNCTION EXECUTORS
 ----------------------------------------------------------- */
-async function executeFunction<Model extends ILlmSchema.Model>(
-  call: AgenticaCallEvent<Model>,
-  operation: AgenticaOperation<Model>,
-): Promise<AgenticaExecuteEvent<Model>> {
+async function executeFunction(
+  call: AgenticaCallEvent,
+  operation: AgenticaOperation,
+): Promise<AgenticaExecuteEvent> {
   try {
     const value: unknown = await (async () => {
       switch (operation.protocol) {
@@ -473,9 +472,9 @@ async function executeFunction<Model extends ILlmSchema.Model>(
   }
 }
 
-async function executeClassFunction<Model extends ILlmSchema.Model>(
-  call: AgenticaCallEvent<Model>,
-  operation: AgenticaOperation.Class<Model>,
+async function executeClassFunction(
+  call: AgenticaCallEvent,
+  operation: AgenticaOperation.Class,
 ): Promise<unknown> {
   const execute = operation.controller.execute;
   const value: unknown = typeof execute === "function"
@@ -490,9 +489,9 @@ async function executeClassFunction<Model extends ILlmSchema.Model>(
   return value;
 }
 
-async function executeHttpOperation<Model extends ILlmSchema.Model>(
-  call: AgenticaCallEvent<Model>,
-  operation: AgenticaOperation.Http<Model>,
+async function executeHttpOperation(
+  call: AgenticaCallEvent,
+  operation: AgenticaOperation.Http,
 ): Promise<unknown> {
   const execute = operation.controller.execute;
   const value: IHttpResponse = typeof execute === "function"
@@ -511,9 +510,9 @@ async function executeHttpOperation<Model extends ILlmSchema.Model>(
   return value;
 }
 
-async function executeMcpOperation<Model extends ILlmSchema.Model>(
-  call: AgenticaCallEvent<Model>,
-  operation: AgenticaOperation.Mcp<Model>,
+async function executeMcpOperation(
+  call: AgenticaCallEvent,
+  operation: AgenticaOperation.Mcp,
 ): Promise<unknown> {
   return operation.controller.client.callTool({
     method: operation.function.name,

package/src/orchestrate/cancel.ts

@@ -1,4 +1,4 @@
-import type { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import type { ILlmApplication } from "@samchon/openapi";
 import type OpenAI from "openai";
 import type { IValidation } from "typia";
 
@@ -22,9 +22,8 @@ import { StreamUtil } from "../utils/StreamUtil";
 
 import { cancelFunctionFromContext } from "./internal/cancelFunctionFromContext";
 
-const CONTAINER: ILlmApplication<"chatgpt"> = typia.llm.application<
-  __IChatCancelFunctionsApplication,
-  "chatgpt"
+const CONTAINER: ILlmApplication = typia.llm.application<
+  __IChatCancelFunctionsApplication
 >();
 
 interface IFailure {
@@ -33,16 +32,16 @@ interface IFailure {
   validation: IValidation.IFailure;
 }
 
-export async function cancel<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model>,
+export async function cancel(
+  ctx: AgenticaContext,
 ): Promise<void> {
   if (ctx.operations.divided === undefined) {
     return step(ctx, ctx.operations.array, 0);
   }
 
-  const stacks: AgenticaOperationSelection<Model>[][]
+  const stacks: AgenticaOperationSelection[][]
       = ctx.operations.divided.map(() => []);
-  const events: AgenticaEvent<Model>[] = [];
+  const events: AgenticaEvent[] = [];
   await Promise.all(
     ctx.operations.divided.map(async (operations, i) =>
       step(
@@ -78,7 +77,7 @@ export async function cancel<Model extends ILlmSchema.Model>(
     );
   }
   else {
-    const cancelled: AgenticaCancelEvent<Model>[]
+    const cancelled: AgenticaCancelEvent[]
         = events.filter(e => e.type === "cancel");
     (cancelled.length !== 0 ? cancelled : events)
       .forEach((e) => {
@@ -87,9 +86,9 @@ export async function cancel<Model extends ILlmSchema.Model>(
   }
 }
 
-async function step<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model>,
-  operations: AgenticaOperation<Model>[],
+async function step(
+  ctx: AgenticaContext,
+  operations: AgenticaOperation[],
   retry: number,
   failures?: IFailure[],
 ): Promise<void> {

package/src/orchestrate/describe.ts

@@ -1,4 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
 import type OpenAI from "openai";
 
 import type { AgenticaContext } from "../context/AgenticaContext";
@@ -12,9 +11,9 @@ import { createDescribeEvent } from "../factory/events";
 import { decodeHistory } from "../factory/histories";
 import { reduceStreamingWithDispatch } from "../utils/ChatGptCompletionStreamingUtil";
 
-export async function describe<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
-  histories: AgenticaExecuteHistory<Model>[],
+export async function describe(
+  ctx: AgenticaContext | MicroAgenticaContext,
+  histories: AgenticaExecuteHistory[],
 ): Promise<void> {
   if (histories.length === 0) {
     return;
@@ -40,7 +39,7 @@ export async function describe<Model extends ILlmSchema.Model>(
   });
 
   await reduceStreamingWithDispatch(completionStream, (props) => {
-    const event: AgenticaDescribeEvent<Model> = createDescribeEvent({
+    const event: AgenticaDescribeEvent = createDescribeEvent({
       executes: histories,
       ...props,
     });

package/src/orchestrate/execute.ts

@@ -1,5 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaContext } from "../context/AgenticaContext";
 import type { AgenticaExecuteEvent } from "../events";
 import type { IAgenticaExecutor } from "../structures/IAgenticaExecutor";
@@ -10,8 +8,8 @@ import { describe } from "./describe";
 import { initialize } from "./initialize";
 import { select } from "./select";
 
-export function execute<Model extends ILlmSchema.Model>(executor: Partial<IAgenticaExecutor<Model>> | null) {
-  return async (ctx: AgenticaContext<Model>): Promise<void> => {
+export function execute(executor: Partial<IAgenticaExecutor> | null) {
+  return async (ctx: AgenticaContext): Promise<void> => {
     // FUNCTIONS ARE NOT LISTED YET
     if (ctx.ready() === false) {
       if (executor?.initialize !== true && typeof executor?.initialize !== "function") {
@@ -43,7 +41,7 @@ export function execute<Model extends ILlmSchema.Model>(executor: Partial<IAgent
     // FUNCTION CALLING LOOP
     while (true) {
       // EXECUTE FUNCTIONS
-      const executes: AgenticaExecuteEvent<Model>[] = await (
+      const executes: AgenticaExecuteEvent[] = await (
         executor?.call ?? call
       )(ctx, ctx.stack.map(s => s.operation));
 

package/src/orchestrate/initialize.ts

@@ -1,4 +1,4 @@
-import type { ILlmFunction, ILlmSchema } from "@samchon/openapi";
+import type { ILlmFunction } from "@samchon/openapi";
 import type OpenAI from "openai";
 
 import typia from "typia";
@@ -13,12 +13,11 @@ import { createAssistantMessageEvent } from "../factory/events";
 import { decodeHistory, decodeUserMessageContent } from "../factory/histories";
 import { reduceStreamingWithDispatch } from "../utils/ChatGptCompletionStreamingUtil";
 
-const FUNCTION: ILlmFunction<"chatgpt"> = typia.llm.application<
-  __IChatInitialApplication,
-  "chatgpt"
+const FUNCTION: ILlmFunction = typia.llm.application<
+  __IChatInitialApplication
 >().functions[0]!;
 
-export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>): Promise<void> {
+export async function initialize(ctx: AgenticaContext): Promise<void> {
   // ----
   // EXECUTE CHATGPT API
   // ----

package/src/orchestrate/internal/cancelFunctionFromContext.ts

@@ -1,5 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaContext } from "../../context/AgenticaContext";
 import type { AgenticaOperationSelection } from "../../context/AgenticaOperationSelection";
 import type { __IChatFunctionReference } from "../../context/internal/__IChatFunctionReference";
@@ -11,8 +9,8 @@ import { createOperationSelection } from "../../factory/operations";
 /**
  * @internal
  */
-export function cancelFunctionFromContext<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model>,
+export function cancelFunctionFromContext(
+  ctx: AgenticaContext,
   reference: __IChatFunctionReference,
 ): void {
   const index: number = ctx.stack.findIndex(
@@ -22,10 +20,10 @@ export function cancelFunctionFromContext<Model extends ILlmSchema.Model>(
     return;
   }
 
-  const item: AgenticaOperationSelection<Model> = ctx.stack[index]!;
+  const item: AgenticaOperationSelection = ctx.stack[index]!;
   ctx.stack.splice(index, 1);
 
-  const event: AgenticaCancelEvent<Model> = createCancelEvent({
+  const event: AgenticaCancelEvent = createCancelEvent({
     selection: createOperationSelection({
       operation: item.operation,
       reason: reference.reason,

package/src/orchestrate/internal/selectFunctionFromContext.ts

@@ -1,5 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaContext } from "../../context/AgenticaContext";
 import type { AgenticaOperation } from "../../context/AgenticaOperation";
 import type { AgenticaOperationSelection } from "../../context/AgenticaOperationSelection";
@@ -12,26 +10,24 @@ import { createOperationSelection } from "../../factory/operations";
 /**
  * @internal
  */
-export function selectFunctionFromContext<
-  Model extends ILlmSchema.Model,
->(
-  ctx: AgenticaContext<Model>,
+export function selectFunctionFromContext(
+  ctx: AgenticaContext,
   reference: __IChatFunctionReference,
 ): void {
-  const operation: AgenticaOperation<Model> | undefined
+  const operation: AgenticaOperation | undefined
     = ctx.operations.flat.get(reference.name);
   if (operation === undefined) {
     return;
   }
 
-  const selection: AgenticaOperationSelection<Model>
+  const selection: AgenticaOperationSelection
     = createOperationSelection({
       operation,
       reason: reference.reason,
     });
   ctx.stack.push(selection);
 
-  const event: AgenticaSelectEvent<Model> = createSelectEvent({
+  const event: AgenticaSelectEvent = createSelectEvent({
     selection,
   });
   void ctx.dispatch(event).catch(() => {});

package/src/orchestrate/select.ts

@@ -1,4 +1,4 @@
-import type { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import type { ILlmApplication } from "@samchon/openapi";
 import type OpenAI from "openai";
 import type { IValidation } from "typia";
 
@@ -25,9 +25,8 @@ import { toAsyncGenerator } from "../utils/StreamUtil";
 
 import { selectFunctionFromContext } from "./internal/selectFunctionFromContext";
 
-const CONTAINER: ILlmApplication<"chatgpt"> = typia.llm.application<
-  __IChatSelectFunctionsApplication,
-  "chatgpt"
+const CONTAINER: ILlmApplication = typia.llm.application<
+  __IChatSelectFunctionsApplication
 >();
 
 interface IFailure {
@@ -36,16 +35,16 @@ interface IFailure {
   validation: IValidation.IFailure;
 }
 
-export async function select<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model>,
+export async function select(
+  ctx: AgenticaContext,
 ): Promise<void> {
   if (ctx.operations.divided === undefined) {
     return step(ctx, ctx.operations.array, 0);
   }
 
-  const stacks: AgenticaOperationSelection<Model>[][]
+  const stacks: AgenticaOperationSelection[][]
     = ctx.operations.divided.map(() => []);
-  const events: AgenticaEvent<Model>[] = [];
+  const events: AgenticaEvent[] = [];
   await Promise.all(
     ctx.operations.divided.map(async (operations, i) =>
       step(
@@ -81,7 +80,7 @@ export async function select<Model extends ILlmSchema.Model>(
     );
   }
   else {
-    const selected: AgenticaSelectEvent<Model>[]
+    const selected: AgenticaSelectEvent[]
       = events.filter(e => e.type === "select");
     (selected.length !== 0 ? selected : events)
       .forEach((e) => {
@@ -90,9 +89,9 @@ export async function select<Model extends ILlmSchema.Model>(
   }
 }
 
-async function step<Model extends ILlmSchema.Model>(
-  ctx: AgenticaContext<Model>,
-  operations: AgenticaOperation<Model>[],
+async function step(
+  ctx: AgenticaContext,
+  operations: AgenticaOperation[],
   retry: number,
   failures?: IFailure[],
 ): Promise<void> {

package/src/structures/IAgenticaConfig.ts

@@ -1,5 +1,3 @@
-import type { ILlmSchema } from "@samchon/openapi";
-
 import type { AgenticaContext } from "../context/AgenticaContext";
 
 import type { IAgenticaExecutor } from "./IAgenticaExecutor";
@@ -22,7 +20,7 @@ import type { IAgenticaSystemPrompt } from "./IAgenticaSystemPrompt";
  *
  * @author Samchon
  */
-export interface IAgenticaConfig<Model extends ILlmSchema.Model> {
+export interface IAgenticaConfig {
   /**
    * Agent executor.
    *
@@ -38,8 +36,8 @@ export interface IAgenticaConfig<Model extends ILlmSchema.Model> {
    * @default ChatGptAgent.execute
    */
   executor?:
-    | Partial<IAgenticaExecutor<Model>>
-    | ((ctx: AgenticaContext<Model>) => Promise<void>);
+    | Partial<IAgenticaExecutor>
+    | ((ctx: AgenticaContext) => Promise<void>);
 
   /**
    * System prompt messages.
@@ -47,7 +45,7 @@ export interface IAgenticaConfig<Model extends ILlmSchema.Model> {
    * System prompt messages if you want to customize the system prompt
    * messages for each situation.
    */
-  systemPrompt?: IAgenticaSystemPrompt<Model>;
+  systemPrompt?: IAgenticaSystemPrompt;
 
   /**
    * Locale of the A.I. chatbot.