@agentica/core 0.8.3-dev.20250227 → 0.9.0-dev.20250302

package/src/chatgpt/ChatGptCallFunctionAgent.ts

@@ -4,6 +4,7 @@ import {
   IChatGptSchema,
   IHttpMigrateRoute,
   IHttpResponse,
+  ILlmSchema,
 } from "@samchon/openapi";
 import OpenAI from "openai";
 import { IValidation } from "typia";
@@ -20,9 +21,9 @@ import { ChatGptCancelFunctionAgent } from "./ChatGptCancelFunctionAgent";
 import { ChatGptHistoryDecoder } from "./ChatGptHistoryDecoder";
 
 export namespace ChatGptCallFunctionAgent {
-  export const execute = async (
-    ctx: IAgenticaContext,
-  ): Promise<IAgenticaPrompt[]> => {
+  export const execute = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
+  ): Promise<IAgenticaPrompt<Model>[]> => {
     //----
     // EXECUTE CHATGPT API
     //----
@@ -79,8 +80,8 @@ export namespace ChatGptCallFunctionAgent {
     const closures: Array<
       () => Promise<
         Array<
-          | IAgenticaPrompt.IExecute
-          | IAgenticaPrompt.ICancel
+          | IAgenticaPrompt.IExecute<Model>
+          | IAgenticaPrompt.ICancel<Model>
           | IAgenticaPrompt.IText
         >
       >
@@ -88,14 +89,14 @@ export namespace ChatGptCallFunctionAgent {
     for (const choice of completion.choices) {
       for (const tc of choice.message.tool_calls ?? []) {
         if (tc.type === "function") {
-          const operation: IAgenticaOperation | undefined =
+          const operation: IAgenticaOperation<Model> | undefined =
             ctx.operations.flat.get(tc.function.name);
           if (operation === undefined) continue;
           closures.push(
             async (): Promise<
-              [IAgenticaPrompt.IExecute, IAgenticaPrompt.ICancel]
+              [IAgenticaPrompt.IExecute<Model>, IAgenticaPrompt.ICancel<Model>]
             > => {
-              const call: IAgenticaEvent.ICall = {
+              const call: IAgenticaEvent.ICall<Model> = {
                 type: "call",
                 id: tc.id,
                 operation,
@@ -108,7 +109,7 @@ export namespace ChatGptCallFunctionAgent {
                 });
               await ctx.dispatch(call);
 
-              const execute: IAgenticaPrompt.IExecute = await propagate(
+              const execute: IAgenticaPrompt.IExecute<Model> = await propagate(
                 ctx,
                 call,
                 0,
@@ -141,7 +142,7 @@ export namespace ChatGptCallFunctionAgent {
                       reason: "complete",
                     }),
                   ],
-                } satisfies IAgenticaPrompt.ICancel,
+                } satisfies IAgenticaPrompt.ICancel<Model>,
               ] as const;
             },
           );
@@ -164,11 +165,11 @@ export namespace ChatGptCallFunctionAgent {
     return (await Promise.all(closures.map((fn) => fn()))).flat();
   };
 
-  const propagate = async (
-    ctx: IAgenticaContext,
-    call: IAgenticaEvent.ICall,
+  const propagate = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
+    call: IAgenticaEvent.ICall<Model>,
     retry: number,
-  ): Promise<IAgenticaPrompt.IExecute> => {
+  ): Promise<IAgenticaPrompt.IExecute<Model>> => {
     if (call.operation.protocol === "http") {
       //----
       // HTTP PROTOCOL
@@ -307,12 +308,12 @@ export namespace ChatGptCallFunctionAgent {
     }
   };
 
-  const correct = async (
-    ctx: IAgenticaContext,
-    call: IAgenticaEvent.ICall,
+  const correct = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
+    call: IAgenticaEvent.ICall<Model>,
     retry: number,
     error: unknown,
-  ): Promise<IAgenticaPrompt.IExecute | null> => {
+  ): Promise<IAgenticaPrompt.IExecute<Model> | null> => {
     //----
     // EXECUTE CHATGPT API
     //----
@@ -410,8 +411,8 @@ export namespace ChatGptCallFunctionAgent {
     );
   };
 
-  const fillHttpArguments = (props: {
-    operation: IAgenticaOperation;
+  const fillHttpArguments = <Model extends ILlmSchema.Model>(props: {
+    operation: IAgenticaOperation<Model>;
     arguments: object;
   }): void => {
     if (props.operation.protocol !== "http") return;
@@ -421,8 +422,10 @@ export namespace ChatGptCallFunctionAgent {
       route.operation().requestBody?.required === true &&
       (props.arguments as any).body === undefined &&
       isObject(
-        props.operation.function.parameters.$defs,
-        props.operation.function.parameters.properties.body!,
+        (props.operation.function.parameters as IChatGptSchema.IParameters)
+          .$defs,
+        (props.operation.function.parameters as IChatGptSchema.IParameters)
+          .properties.body!,
       )
     )
       (props.arguments as any).body = {};

package/src/chatgpt/ChatGptCancelFunctionAgent.ts

@@ -1,4 +1,8 @@
-import { IHttpLlmFunction, ILlmApplication } from "@samchon/openapi";
+import {
+  IHttpLlmFunction,
+  ILlmApplication,
+  ILlmSchema,
+} from "@samchon/openapi";
 import OpenAI from "openai";
 import typia, { IValidation } from "typia";
 import { v4 } from "uuid";
@@ -18,17 +22,16 @@ import { __IChatFunctionReference } from "../structures/internal/__IChatFunction
 import { ChatGptHistoryDecoder } from "./ChatGptHistoryDecoder";
 
 export namespace ChatGptCancelFunctionAgent {
-  export const execute = async (
-    ctx: IAgenticaContext,
-  ): Promise<IAgenticaPrompt.ICancel[]> => {
+  export const execute = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
+  ): Promise<IAgenticaPrompt.ICancel<Model>[]> => {
     if (ctx.operations.divided === undefined)
       return step(ctx, ctx.operations.array, 0);
 
-    const stacks: IAgenticaOperationSelection[][] = ctx.operations.divided.map(
-      () => [],
-    );
-    const events: IAgenticaEvent[] = [];
-    const prompts: IAgenticaPrompt.ICancel[][] = await Promise.all(
+    const stacks: IAgenticaOperationSelection<Model>[][] =
+      ctx.operations.divided.map(() => []);
+    const events: IAgenticaEvent<Model>[] = [];
+    const prompts: IAgenticaPrompt.ICancel<Model>[][] = await Promise.all(
       ctx.operations.divided.map((operations, i) =>
         step(
           {
@@ -62,7 +65,7 @@ export namespace ChatGptCancelFunctionAgent {
       );
 
     // RE-COLLECT SELECT FUNCTION EVENTS
-    const collection: IAgenticaPrompt.ICancel = {
+    const collection: IAgenticaPrompt.ICancel<Model> = {
       id: v4(),
       type: "cancel",
       operations: [],
@@ -72,8 +75,9 @@ export namespace ChatGptCancelFunctionAgent {
         collection.operations.push(
           AgenticaPromptFactory.selection({
             protocol: e.operation.protocol as "http",
-            controller: e.operation.controller as IAgenticaController.IHttp,
-            function: e.operation.function as IHttpLlmFunction<"chatgpt">,
+            controller: e.operation
+              .controller as IAgenticaController.IHttp<Model>,
+            function: e.operation.function as IHttpLlmFunction<Model>,
             reason: e.reason,
             name: e.operation.name,
           }),
@@ -86,16 +90,16 @@ export namespace ChatGptCancelFunctionAgent {
     return [collection];
   };
 
-  export const cancelFunction = async (
-    ctx: IAgenticaContext,
+  export const cancelFunction = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
     reference: __IChatFunctionReference,
-  ): Promise<IAgenticaOperationSelection | null> => {
+  ): Promise<IAgenticaOperationSelection<Model> | null> => {
     const index: number = ctx.stack.findIndex(
       (item) => item.name === reference.name,
     );
     if (index === -1) return null;
 
-    const item: IAgenticaOperationSelection = ctx.stack[index]!;
+    const item: IAgenticaOperationSelection<Model> = ctx.stack[index]!;
     ctx.stack.splice(index, 1);
     await ctx.dispatch({
       type: "cancel",
@@ -105,12 +109,12 @@ export namespace ChatGptCancelFunctionAgent {
     return item;
   };
 
-  const step = async (
-    ctx: IAgenticaContext,
-    operations: IAgenticaOperation[],
+  const step = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
+    operations: IAgenticaOperation<Model>[],
     retry: number,
     failures?: IFailure[],
-  ): Promise<IAgenticaPrompt.ICancel[]> => {
+  ): Promise<IAgenticaPrompt.ICancel<Model>[]> => {
     //----
     // EXECUTE CHATGPT API
     //----
@@ -209,7 +213,7 @@ export namespace ChatGptCancelFunctionAgent {
     //----
     // PROCESS COMPLETION
     //----
-    const prompts: IAgenticaPrompt.ICancel[] = [];
+    const prompts: IAgenticaPrompt.ICancel<Model>[] = [];
     for (const choice of completion.choices) {
       // TOOL CALLING HANDLER
       if (choice.message.tool_calls)
@@ -220,7 +224,7 @@ export namespace ChatGptCancelFunctionAgent {
           );
           if (typia.is(input) === false) continue;
           else if (tc.function.name === "cancelFunctions") {
-            const collection: IAgenticaPrompt.ICancel = {
+            const collection: IAgenticaPrompt.ICancel<Model> = {
               id: tc.id,
               type: "cancel",
               operations: [],

package/src/chatgpt/ChatGptDescribeFunctionAgent.ts

@@ -1,3 +1,4 @@
+import { ILlmSchema } from "@samchon/openapi";
 import OpenAI from "openai";
 
 import { AgenticaDefaultPrompt } from "../internal/AgenticaDefaultPrompt";
@@ -7,10 +8,10 @@ import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
 import { ChatGptHistoryDecoder } from "./ChatGptHistoryDecoder";
 
 export namespace ChatGptDescribeFunctionAgent {
-  export const execute = async (
-    ctx: IAgenticaContext,
-    histories: IAgenticaPrompt.IExecute[],
-  ): Promise<IAgenticaPrompt.IDescribe[]> => {
+  export const execute = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
+    histories: IAgenticaPrompt.IExecute<Model>[],
+  ): Promise<IAgenticaPrompt.IDescribe<Model>[]> => {
     if (histories.length === 0) return [];
     const completion: OpenAI.ChatCompletion = await ctx.request("describe", {
       messages: [
@@ -30,7 +31,7 @@ export namespace ChatGptDescribeFunctionAgent {
         },
       ],
     });
-    const descriptions: IAgenticaPrompt.IDescribe[] = completion.choices
+    const descriptions: IAgenticaPrompt.IDescribe<Model>[] = completion.choices
       .map((choice) =>
         choice.message.role === "assistant" && !!choice.message.content?.length
           ? choice.message.content
@@ -43,7 +44,7 @@ export namespace ChatGptDescribeFunctionAgent {
             type: "describe",
             executions: histories,
             text: content,
-          }) satisfies IAgenticaPrompt.IDescribe,
+          }) satisfies IAgenticaPrompt.IDescribe<Model>,
       );
     for (const describe of descriptions) await ctx.dispatch(describe);
     return descriptions;

package/src/chatgpt/ChatGptHistoryDecoder.ts

@@ -1,10 +1,11 @@
+import { ILlmSchema } from "@samchon/openapi";
 import OpenAI from "openai";
 
 import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
 
 export namespace ChatGptHistoryDecoder {
-  export const decode = (
-    history: IAgenticaPrompt,
+  export const decode = <Model extends ILlmSchema.Model>(
+    history: IAgenticaPrompt<Model>,
   ): OpenAI.ChatCompletionMessageParam[] => {
     // NO NEED TO DECODE DESCRIBE
     if (history.type === "describe") return [];

package/src/chatgpt/ChatGptInitializeFunctionAgent.ts

@@ -1,4 +1,4 @@
-import { ILlmFunction } from "@samchon/openapi";
+import { ILlmFunction, ILlmSchema } from "@samchon/openapi";
 import OpenAI from "openai";
 import typia from "typia";
 
@@ -10,9 +10,9 @@ import { __IChatInitialApplication } from "../structures/internal/__IChatInitial
 import { ChatGptHistoryDecoder } from "./ChatGptHistoryDecoder";
 
 export namespace ChatGptInitializeFunctionAgent {
-  export const execute = async (
-    ctx: IAgenticaContext,
-  ): Promise<IAgenticaPrompt[]> => {
+  export const execute = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
+  ): Promise<IAgenticaPrompt<Model>[]> => {
     //----
     // EXECUTE CHATGPT API
     //----
@@ -56,7 +56,7 @@ export namespace ChatGptInitializeFunctionAgent {
     //----
     // PROCESS COMPLETION
     //----
-    const prompts: IAgenticaPrompt[] = [];
+    const prompts: IAgenticaPrompt<Model>[] = [];
     for (const choice of completion.choices) {
       if (
         choice.message.role === "assistant" &&

package/src/chatgpt/ChatGptSelectFunctionAgent.ts

@@ -1,4 +1,8 @@
-import { IHttpLlmFunction, ILlmApplication } from "@samchon/openapi";
+import {
+  IHttpLlmFunction,
+  ILlmApplication,
+  ILlmSchema,
+} from "@samchon/openapi";
 import OpenAI from "openai";
 import typia, { IValidation } from "typia";
 import { v4 } from "uuid";
@@ -18,17 +22,16 @@ import { __IChatSelectFunctionsApplication } from "../structures/internal/__ICha
 import { ChatGptHistoryDecoder } from "./ChatGptHistoryDecoder";
 
 export namespace ChatGptSelectFunctionAgent {
-  export const execute = async (
-    ctx: IAgenticaContext,
-  ): Promise<IAgenticaPrompt[]> => {
+  export const execute = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
+  ): Promise<IAgenticaPrompt<Model>[]> => {
     if (ctx.operations.divided === undefined)
       return step(ctx, ctx.operations.array, 0);
 
-    const stacks: IAgenticaOperationSelection[][] = ctx.operations.divided.map(
-      () => [],
-    );
-    const events: IAgenticaEvent[] = [];
-    const prompts: IAgenticaPrompt[][] = await Promise.all(
+    const stacks: IAgenticaOperationSelection<Model>[][] =
+      ctx.operations.divided.map(() => []);
+    const events: IAgenticaEvent<Model>[] = [];
+    const prompts: IAgenticaPrompt<Model>[][] = await Promise.all(
       ctx.operations.divided.map((operations, i) =>
         step(
           {
@@ -62,7 +65,7 @@ export namespace ChatGptSelectFunctionAgent {
       );
 
     // RE-COLLECT SELECT FUNCTION EVENTS
-    const collection: IAgenticaPrompt.ISelect = {
+    const collection: IAgenticaPrompt.ISelect<Model> = {
       id: v4(),
       type: "select",
       operations: [],
@@ -72,8 +75,9 @@ export namespace ChatGptSelectFunctionAgent {
         collection.operations.push(
           AgenticaPromptFactory.selection({
             protocol: e.operation.protocol as "http",
-            controller: e.operation.controller as IAgenticaController.IHttp,
-            function: e.operation.function as IHttpLlmFunction<"chatgpt">,
+            controller: e.operation
+              .controller as IAgenticaController.IHttp<Model>,
+            function: e.operation.function as IHttpLlmFunction<Model>,
             reason: e.reason,
             name: e.operation.name,
           }),
@@ -86,12 +90,12 @@ export namespace ChatGptSelectFunctionAgent {
     return [collection];
   };
 
-  const step = async (
-    ctx: IAgenticaContext,
-    operations: IAgenticaOperation[],
+  const step = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
+    operations: IAgenticaOperation<Model>[],
     retry: number,
     failures?: IFailure[],
-  ): Promise<IAgenticaPrompt[]> => {
+  ): Promise<IAgenticaPrompt<Model>[]> => {
     //----
     // EXECUTE CHATGPT API
     //----
@@ -190,7 +194,7 @@ export namespace ChatGptSelectFunctionAgent {
     //----
     // PROCESS COMPLETION
     //----
-    const prompts: IAgenticaPrompt[] = [];
+    const prompts: IAgenticaPrompt<Model>[] = [];
     for (const choice of completion.choices) {
       // TOOL CALLING HANDLER
       if (choice.message.tool_calls)
@@ -202,23 +206,21 @@ export namespace ChatGptSelectFunctionAgent {
           );
           if (typia.is(input) === false) continue;
           else if (tc.function.name === "selectFunctions") {
-            const collection: IAgenticaPrompt.ISelect = {
+            const collection: IAgenticaPrompt.ISelect<Model> = {
               id: tc.id,
               type: "select",
               operations: [],
             };
             for (const reference of input.functions) {
-              const operation: IAgenticaOperation | null = await selectFunction(
-                ctx,
-                reference,
-              );
+              const operation: IAgenticaOperation<Model> | null =
+                await selectFunction(ctx, reference);
               if (operation !== null)
                 collection.operations.push(
                   AgenticaPromptFactory.selection({
                     protocol: operation.protocol as "http",
                     controller:
-                      operation.controller as IAgenticaController.IHttp,
-                    function: operation.function as IHttpLlmFunction<"chatgpt">,
+                      operation.controller as IAgenticaController.IHttp<Model>,
+                    function: operation.function as IHttpLlmFunction<Model>,
                     name: operation.name,
                     reason: reference.reason,
                   }),
@@ -245,20 +247,19 @@ export namespace ChatGptSelectFunctionAgent {
     return prompts;
   };
 
-  const selectFunction = async (
-    ctx: IAgenticaContext,
+  const selectFunction = async <Model extends ILlmSchema.Model>(
+    ctx: IAgenticaContext<Model>,
     reference: __IChatFunctionReference,
-  ): Promise<IAgenticaOperation | null> => {
-    const operation: IAgenticaOperation | undefined = ctx.operations.flat.get(
-      reference.name,
-    );
+  ): Promise<IAgenticaOperation<Model> | null> => {
+    const operation: IAgenticaOperation<Model> | undefined =
+      ctx.operations.flat.get(reference.name);
     if (operation === undefined) return null;
 
     ctx.stack.push(
       AgenticaPromptFactory.selection({
         protocol: operation.protocol as "http",
-        controller: operation.controller as IAgenticaController.IHttp,
-        function: operation.function as IHttpLlmFunction<"chatgpt">,
+        controller: operation.controller as IAgenticaController.IHttp<Model>,
+        function: operation.function as IHttpLlmFunction<Model>,
         name: reference.name,
         reason: reference.reason,
       }),

package/src/internal/AgenticaDefaultPrompt.ts

@@ -1,9 +1,13 @@
+import { ILlmSchema } from "@samchon/openapi";
+
 import { IAgenticaConfig } from "../structures/IAgenticaConfig";
 import { AgenticaSystemPrompt } from "./AgenticaSystemPrompt";
 import { Singleton } from "./Singleton";
 
 export namespace AgenticaDefaultPrompt {
-  export const write = (config?: IAgenticaConfig): string => {
+  export const write = <Model extends ILlmSchema.Model>(
+    config?: IAgenticaConfig<Model>,
+  ): string => {
     if (config?.systemPrompt?.common)
       return config?.systemPrompt?.common(config);
 

package/src/internal/AgenticaOperationComposer.ts

@@ -1,3 +1,5 @@
+import { ILlmSchema } from "@samchon/openapi";
+
 import { IAgenticaConfig } from "../structures/IAgenticaConfig";
 import { IAgenticaController } from "../structures/IAgenticaController";
 import { IAgenticaOperation } from "../structures/IAgenticaOperation";
@@ -5,10 +7,10 @@ import { IAgenticaOperationCollection } from "../structures/IAgenticaOperationCo
 import { __map_take } from "./__map_take";
 
 export namespace AgenticaOperationComposer {
-  export const compose = (props: {
-    controllers: IAgenticaController[];
-    config?: IAgenticaConfig | undefined;
-  }): IAgenticaOperationCollection => {
+  export const compose = <Model extends ILlmSchema.Model>(props: {
+    controllers: IAgenticaController<Model>[];
+    config?: IAgenticaConfig<Model> | undefined;
+  }): IAgenticaOperationCollection<Model> => {
     const unique: boolean =
       props.controllers.length === 1 ||
       (() => {
@@ -22,17 +24,17 @@ export namespace AgenticaOperationComposer {
     const naming = (func: string, ci: number) =>
       unique ? func : `_${ci}_${func}`;
 
-    const array: IAgenticaOperation[] = props.controllers
+    const array: IAgenticaOperation<Model>[] = props.controllers
       .map((controller, ci) =>
         controller.protocol === "http"
           ? controller.application.functions.map(
               (func) =>
                 ({
                   protocol: "http",
-                  controller,
+                  controller: controller,
                   function: func,
                   name: naming(func.name, ci),
-                }) satisfies IAgenticaOperation.IHttp,
+                }) satisfies IAgenticaOperation.IHttp<Model>,
             )
           : controller.application.functions.map(
               (func) =>
@@ -41,11 +43,11 @@ export namespace AgenticaOperationComposer {
                   controller,
                   function: func,
                   name: naming(func.name, ci),
-                }) satisfies IAgenticaOperation.IClass,
+                }) satisfies IAgenticaOperation.IClass<Model>,
             ),
       )
       .flat();
-    const divided: IAgenticaOperation[][] | undefined =
+    const divided: IAgenticaOperation<Model>[][] | undefined =
       !!props.config?.capacity && array.length > props.config.capacity
         ? divideOperations({
             array,
@@ -53,8 +55,11 @@ export namespace AgenticaOperationComposer {
           })
         : undefined;
 
-    const flat: Map<string, IAgenticaOperation> = new Map();
-    const group: Map<string, Map<string, IAgenticaOperation>> = new Map();
+    const flat: Map<string, IAgenticaOperation<Model>> = new Map();
+    const group: Map<
+      string,
+      Map<string, IAgenticaOperation<Model>>
+    > = new Map();
     for (const item of array) {
       flat.set(item.name, item);
       __map_take(group, item.controller.name, () => new Map()).set(
@@ -70,13 +75,13 @@ export namespace AgenticaOperationComposer {
     };
   };
 
-  const divideOperations = (props: {
-    array: IAgenticaOperation[];
+  const divideOperations = <Model extends ILlmSchema.Model>(props: {
+    array: IAgenticaOperation<Model>[];
     capacity: number;
-  }): IAgenticaOperation[][] => {
+  }): IAgenticaOperation<Model>[][] => {
     const size: number = Math.ceil(props.array.length / props.capacity);
     const capacity: number = Math.ceil(props.array.length / size);
-    const replica: IAgenticaOperation[] = props.array.slice();
+    const replica: IAgenticaOperation<Model>[] = props.array.slice();
     return new Array(size).fill(0).map(() => replica.splice(0, capacity));
   };
 }

package/src/internal/AgenticaPromptFactory.ts

@@ -1,10 +1,12 @@
+import { ILlmSchema } from "@samchon/openapi";
+
 import { IAgenticaOperationSelection } from "../structures/IAgenticaOperationSelection";
 import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
 
 export namespace AgenticaPromptFactory {
-  export const execute = (
-    props: Omit<IAgenticaPrompt.IExecute, "toJSON">,
-  ): IAgenticaPrompt.IExecute =>
+  export const execute = <Model extends ILlmSchema.Model>(
+    props: Omit<IAgenticaPrompt.IExecute<Model>, "toJSON">,
+  ): IAgenticaPrompt.IExecute<Model> =>
     ({
       ...props,
       toJSON: () =>
@@ -13,11 +15,11 @@ export namespace AgenticaPromptFactory {
           controller: props.controller.name,
           function: props.function.name,
         }) as any,
-    }) as IAgenticaPrompt.IExecute;
+    }) as IAgenticaPrompt.IExecute<Model>;
 
-  export const selection = (
-    props: Omit<IAgenticaOperationSelection, "toJSON">,
-  ): IAgenticaOperationSelection =>
+  export const selection = <Model extends ILlmSchema.Model>(
+    props: Omit<IAgenticaOperationSelection<Model>, "toJSON">,
+  ): IAgenticaOperationSelection<Model> =>
     ({
       ...props,
       toJSON: () =>
@@ -26,5 +28,5 @@ export namespace AgenticaPromptFactory {
           controller: props.controller.name,
           function: props.function.name,
         }) as any,
-    }) as IAgenticaOperationSelection;
+    }) as IAgenticaOperationSelection<Model>;
 }