@agentica/core 0.10.4 → 0.11.1

package/src/chatgpt/ChatGptSelectFunctionAgent.ts

@@ -1,37 +1,37 @@
-import {
-  IHttpLlmFunction,
-  ILlmApplication,
-  ILlmSchema,
-} from "@samchon/openapi";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import OpenAI from "openai";
 import typia, { IValidation } from "typia";
 import { v4 } from "uuid";
 
+import { AgenticaContext } from "../context/AgenticaContext";
+import { AgenticaOperation } from "../context/AgenticaOperation";
+import { AgenticaOperationSelection } from "../context/AgenticaOperationSelection";
+import { __IChatFunctionReference } from "../context/internal/__IChatFunctionReference";
+import { __IChatSelectFunctionsApplication } from "../context/internal/__IChatSelectFunctionsApplication";
+import { AgenticaEvent } from "../events/AgenticaEvent";
+import { AgenticaSelectEvent } from "../events/AgenticaSelectEvent";
+import { AgenticaTextEvent } from "../events/AgenticaTextEvent";
 import { AgenticaConstant } from "../internal/AgenticaConstant";
 import { AgenticaDefaultPrompt } from "../internal/AgenticaDefaultPrompt";
-import { AgenticaPromptFactory } from "../internal/AgenticaPromptFactory";
 import { AgenticaSystemPrompt } from "../internal/AgenticaSystemPrompt";
-import { IAgenticaContext } from "../structures/IAgenticaContext";
-import { IAgenticaController } from "../structures/IAgenticaController";
-import { IAgenticaEvent } from "../structures/IAgenticaEvent";
-import { IAgenticaOperation } from "../structures/IAgenticaOperation";
-import { IAgenticaOperationSelection } from "../structures/IAgenticaOperationSelection";
-import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
-import { __IChatFunctionReference } from "../structures/internal/__IChatFunctionReference";
-import { __IChatSelectFunctionsApplication } from "../structures/internal/__IChatSelectFunctionsApplication";
+import { StreamUtil } from "../internal/StreamUtil";
+import { AgenticaPrompt } from "../prompts/AgenticaPrompt";
+import { AgenticaSelectPrompt } from "../prompts/AgenticaSelectPrompt";
+import { AgenticaTextPrompt } from "../prompts/AgenticaTextPrompt";
+import { ChatGptCompletionMessageUtil } from "./ChatGptCompletionMessageUtil";
 import { ChatGptHistoryDecoder } from "./ChatGptHistoryDecoder";
 
 export namespace ChatGptSelectFunctionAgent {
   export const execute = async <Model extends ILlmSchema.Model>(
-    ctx: IAgenticaContext<Model>,
-  ): Promise<IAgenticaPrompt<Model>[]> => {
+    ctx: AgenticaContext<Model>,
+  ): Promise<AgenticaPrompt<Model>[]> => {
     if (ctx.operations.divided === undefined)
       return step(ctx, ctx.operations.array, 0);
 
-    const stacks: IAgenticaOperationSelection<Model>[][] =
+    const stacks: AgenticaOperationSelection<Model>[][] =
       ctx.operations.divided.map(() => []);
-    const events: IAgenticaEvent<Model>[] = [];
-    const prompts: IAgenticaPrompt<Model>[][] = await Promise.all(
+    const events: AgenticaEvent<Model>[] = [];
+    const prompts: AgenticaPrompt<Model>[][] = await Promise.all(
       ctx.operations.divided.map((operations, i) =>
         step(
           {
@@ -58,48 +58,38 @@ export namespace ChatGptSelectFunctionAgent {
           .map(
             (s) =>
               ctx.operations.group
-                .get(s.controller.name)!
-                .get(s.function.name)!,
+                .get(s.operation.controller.name)!
+                .get(s.operation.function.name)!,
           ),
         0,
       );
 
     // RE-COLLECT SELECT FUNCTION EVENTS
-    const collection: IAgenticaPrompt.ISelect<Model> = {
+    const collection: AgenticaSelectPrompt<Model> = new AgenticaSelectPrompt({
       id: v4(),
-      type: "select",
-      operations: [],
-    };
+      selections: [],
+    });
     for (const e of events)
       if (e.type === "select") {
-        collection.operations.push(
-          AgenticaPromptFactory.selection({
-            protocol: e.operation.protocol as "http",
-            controller: e.operation
-              .controller as IAgenticaController.IHttp<Model>,
-            function: e.operation.function as IHttpLlmFunction<Model>,
-            reason: e.reason,
-            name: e.operation.name,
-          }),
-        );
+        collection.selections.push(e.selection);
         await selectFunction(ctx, {
-          name: e.operation.name,
-          reason: e.reason,
+          name: e.selection.operation.name,
+          reason: e.selection.reason,
         });
       }
     return [collection];
   };
 
   const step = async <Model extends ILlmSchema.Model>(
-    ctx: IAgenticaContext<Model>,
-    operations: IAgenticaOperation<Model>[],
+    ctx: AgenticaContext<Model>,
+    operations: AgenticaOperation<Model>[],
     retry: number,
     failures?: IFailure[],
-  ): Promise<IAgenticaPrompt<Model>[]> => {
+  ): Promise<AgenticaPrompt<Model>[]> => {
     //----
     // EXECUTE CHATGPT API
     //----
-    const completion: OpenAI.ChatCompletion = await ctx.request("select", {
+    const completionStream = await ctx.request("select", {
       messages: [
         // COMMON SYSTEM PROMPT
         {
@@ -170,6 +160,8 @@ export namespace ChatGptSelectFunctionAgent {
       parallel_tool_calls: false,
     });
 
+    const chunks = await StreamUtil.readAll(completionStream);
+    const completion = ChatGptCompletionMessageUtil.merge(chunks);
     //----
     // VALIDATION
     //----
@@ -194,7 +186,7 @@ export namespace ChatGptSelectFunctionAgent {
     //----
     // PROCESS COMPLETION
     //----
-    const prompts: IAgenticaPrompt<Model>[] = [];
+    const prompts: AgenticaPrompt<Model>[] = [];
     for (const choice of completion.choices) {
       // TOOL CALLING HANDLER
       if (choice.message.tool_calls)
@@ -206,27 +198,23 @@ export namespace ChatGptSelectFunctionAgent {
           );
           if (typia.is(input) === false) continue;
           else if (tc.function.name === "selectFunctions") {
-            const collection: IAgenticaPrompt.ISelect<Model> = {
-              id: tc.id,
-              type: "select",
-              operations: [],
-            };
+            const collection: AgenticaSelectPrompt<Model> =
+              new AgenticaSelectPrompt({
+                id: tc.id,
+                selections: [],
+              });
             for (const reference of input.functions) {
-              const operation: IAgenticaOperation<Model> | null =
+              const operation: AgenticaOperation<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<Model>,
-                    function: operation.function as IHttpLlmFunction<Model>,
-                    name: operation.name,
+                collection.selections.push(
+                  new AgenticaOperationSelection({
+                    operation,
                     reason: reference.reason,
                   }),
                 );
             }
-            if (collection.operations.length !== 0) prompts.push(collection);
+            if (collection.selections.length !== 0) prompts.push(collection);
           }
         }
 
@@ -235,40 +223,44 @@ export namespace ChatGptSelectFunctionAgent {
         choice.message.role === "assistant" &&
         !!choice.message.content?.length
       ) {
-        const text: IAgenticaPrompt.IText = {
-          type: "text",
+        const text: AgenticaTextPrompt = new AgenticaTextPrompt({
           role: "assistant",
           text: choice.message.content,
-        };
+        });
         prompts.push(text);
-        await ctx.dispatch(text);
+        await ctx.dispatch(
+          new AgenticaTextEvent({
+            role: "assistant",
+            stream: StreamUtil.to(text.text),
+            join: () => Promise.resolve(text.text),
+            done: () => true,
+            get: () => text.text,
+          }),
+        );
       }
     }
     return prompts;
   };
 
   const selectFunction = async <Model extends ILlmSchema.Model>(
-    ctx: IAgenticaContext<Model>,
+    ctx: AgenticaContext<Model>,
     reference: __IChatFunctionReference,
-  ): Promise<IAgenticaOperation<Model> | null> => {
-    const operation: IAgenticaOperation<Model> | undefined =
+  ): Promise<AgenticaOperation<Model> | null> => {
+    const operation: AgenticaOperation<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<Model>,
-        function: operation.function as IHttpLlmFunction<Model>,
-        name: reference.name,
+    const selection: AgenticaOperationSelection<Model> =
+      new AgenticaOperationSelection({
+        operation,
         reason: reference.reason,
+      });
+    ctx.stack.push(selection);
+    void ctx.dispatch(
+      new AgenticaSelectEvent({
+        selection,
       }),
     );
-    await ctx.dispatch({
-      type: "select",
-      reason: reference.reason,
-      operation,
-    });
     return operation;
   };
 

package/src/chatgpt/ChatGptUsageAggregator.ts

@@ -0,0 +1,62 @@
+import { CompletionUsage } from "openai/resources";
+
+export namespace ChatGptUsageAggregator {
+  export const sumCompletionTokenDetail = (
+    x: CompletionUsage.CompletionTokensDetails,
+    y: CompletionUsage.CompletionTokensDetails,
+  ): CompletionUsage.CompletionTokensDetails => {
+    return {
+      accepted_prediction_tokens:
+        (x.accepted_prediction_tokens ?? 0) +
+        (y.accepted_prediction_tokens ?? 0),
+      reasoning_tokens: (x.reasoning_tokens ?? 0) + (y.reasoning_tokens ?? 0),
+      rejected_prediction_tokens:
+        (x.rejected_prediction_tokens ?? 0) +
+        (y.rejected_prediction_tokens ?? 0),
+    };
+  };
+
+  export const sumPromptTokenDetail = (
+    x: CompletionUsage.PromptTokensDetails,
+    y: CompletionUsage.PromptTokensDetails,
+  ): CompletionUsage.PromptTokensDetails => {
+    return {
+      audio_tokens: (x.audio_tokens ?? 0) + (y.audio_tokens ?? 0),
+      cached_tokens: (x.cached_tokens ?? 0) + (y.cached_tokens ?? 0),
+    };
+  };
+
+  export const sum = (
+    x: CompletionUsage,
+    y: CompletionUsage,
+  ): CompletionUsage => {
+    return {
+      prompt_tokens: (x.prompt_tokens ?? 0) + (y.prompt_tokens ?? 0),
+      completion_tokens:
+        (x.completion_tokens ?? 0) + (y.completion_tokens ?? 0),
+      total_tokens: (x.total_tokens ?? 0) + (y.total_tokens ?? 0),
+      completion_tokens_details: sumCompletionTokenDetail(
+        x.completion_tokens_details ?? {
+          accepted_prediction_tokens: 0,
+          reasoning_tokens: 0,
+          rejected_prediction_tokens: 0,
+        },
+        y.completion_tokens_details ?? {
+          accepted_prediction_tokens: 0,
+          reasoning_tokens: 0,
+          rejected_prediction_tokens: 0,
+        },
+      ),
+      prompt_tokens_details: sumPromptTokenDetail(
+        x.prompt_tokens_details ?? {
+          audio_tokens: 0,
+          cached_tokens: 0,
+        },
+        y.prompt_tokens_details ?? {
+          audio_tokens: 0,
+          cached_tokens: 0,
+        },
+      ),
+    };
+  };
+}

package/src/context/AgenticaCancelPrompt.ts

@@ -0,0 +1,32 @@
+import { ILlmSchema } from "@samchon/openapi";
+
+import { IAgenticaPromptJson } from "../json/IAgenticaPromptJson";
+import { AgenticaPromptBase } from "../prompts/AgenticaPromptBase";
+import { AgenticaOperationSelection } from "./AgenticaOperationSelection";
+
+export class AgenticaCancelPrompt<
+  Model extends ILlmSchema.Model,
+> extends AgenticaPromptBase<"cancel", IAgenticaPromptJson.ICancel> {
+  public readonly id: string;
+  public readonly selections: AgenticaOperationSelection<Model>[];
+
+  public constructor(props: AgenticaCancelPrompt.IProps<Model>) {
+    super("cancel");
+    this.id = props.id;
+    this.selections = props.selections;
+  }
+
+  public toJSON(): IAgenticaPromptJson.ICancel {
+    return {
+      type: this.type,
+      id: this.id,
+      selections: this.selections.map((s) => s.toJSON()),
+    };
+  }
+}
+export namespace AgenticaCancelPrompt {
+  export interface IProps<Model extends ILlmSchema.Model> {
+    id: string;
+    selections: AgenticaOperationSelection<Model>[];
+  }
+}

package/src/context/AgenticaClassOperation.ts

@@ -0,0 +1,23 @@
+import { ILlmApplication, ILlmFunction, ILlmSchema } from "@samchon/openapi";
+
+import { AgenticaOperationBase } from "./AgenticaOperationBase";
+
+export class AgenticaClassOperation<
+  Model extends ILlmSchema.Model,
+> extends AgenticaOperationBase<
+  "class",
+  ILlmApplication<Model>,
+  ILlmFunction<Model>
+> {
+  public constructor(props: AgenticaClassOperation.IProps<Model>) {
+    super(props);
+  }
+}
+export namespace AgenticaClassOperation {
+  export type IProps<Model extends ILlmSchema.Model> =
+    AgenticaOperationBase.IProps<
+      "class",
+      ILlmApplication<Model>,
+      ILlmFunction<Model>
+    >;
+}

package/src/{structures/IAgenticaContext.ts → context/AgenticaContext.ts}

@@ -1,12 +1,13 @@
 import { ILlmSchema } from "@samchon/openapi";
 import OpenAI from "openai";
 
-import { AgenticaSource } from "../typings/AgenticaSource";
-import { IAgenticaConfig } from "./IAgenticaConfig";
-import { IAgenticaEvent } from "./IAgenticaEvent";
-import { IAgenticaOperationCollection } from "./IAgenticaOperationCollection";
-import { IAgenticaOperationSelection } from "./IAgenticaOperationSelection";
-import { IAgenticaPrompt } from "./IAgenticaPrompt";
+import { AgenticaEvent } from "../events/AgenticaEvent";
+import { AgenticaEventSource } from "../events/AgenticaEventSource";
+import { AgenticaPrompt } from "../prompts/AgenticaPrompt";
+import { AgenticaTextPrompt } from "../prompts/AgenticaTextPrompt";
+import { IAgenticaConfig } from "../structures/IAgenticaConfig";
+import { AgenticaOperationCollection } from "./AgenticaOperationCollection";
+import { AgenticaOperationSelection } from "./AgenticaOperationSelection";
 
 /**
  * Context of the Nestia A.I. agent.
@@ -39,7 +40,7 @@ import { IAgenticaPrompt } from "./IAgenticaPrompt";
  *
  * @author Samchon
  */
-export interface IAgenticaContext<Model extends ILlmSchema.Model> {
+export interface AgenticaContext<Model extends ILlmSchema.Model> {
   //----
   // APPLICATION
   //----
@@ -50,7 +51,7 @@ export interface IAgenticaContext<Model extends ILlmSchema.Model> {
    * groups composed by the divide and conquer rule for the
    * efficient operation selection if configured.
    */
-  operations: IAgenticaOperationCollection<Model>;
+  operations: AgenticaOperationCollection<Model>;
 
   /**
    * Configuration of the agent.
@@ -68,14 +69,14 @@ export interface IAgenticaContext<Model extends ILlmSchema.Model> {
   /**
    * Prompt histories.
    */
-  histories: IAgenticaPrompt<Model>[];
+  histories: AgenticaPrompt<Model>[];
 
   /**
    * Stacked operations.
    *
    * In other words, list of candidate operations for the LLM function calling.
    */
-  stack: IAgenticaOperationSelection<Model>[];
+  stack: AgenticaOperationSelection<Model>[];
 
   /**
    * Text prompt of the user.
@@ -83,7 +84,7 @@ export interface IAgenticaContext<Model extends ILlmSchema.Model> {
    * Text conversation written the by user through the
    * {@link Agentica.conversate} function.
    */
-  prompt: IAgenticaPrompt.IText<"user">;
+  prompt: AgenticaTextPrompt<"user">;
 
   /**
    * Whether the agent is ready.
@@ -91,7 +92,7 @@ export interface IAgenticaContext<Model extends ILlmSchema.Model> {
    * Returns a boolean value indicates whether the agent is ready to
    * perform the function calling.
    *
-   * If the agent has called the {@link IAgenticaContext.initialize},
+   * If the agent has called the {@link AgenticaContext.initialize},
    * it returns `true`. Otherwise the {@link initialize} has never been
    * called, returns `false`.
    */
@@ -108,7 +109,7 @@ export interface IAgenticaContext<Model extends ILlmSchema.Model> {
    *
    * @param event Event to deliver
    */
-  dispatch: (event: IAgenticaEvent<Model>) => Promise<void>;
+  dispatch: (event: AgenticaEvent<Model>) => Promise<void>;
 
   /**
    * Request to the OpenAI server.
@@ -118,9 +119,9 @@ export interface IAgenticaContext<Model extends ILlmSchema.Model> {
    * @returns Response from the OpenAI server
    */
   request: (
-    source: AgenticaSource,
-    body: Omit<OpenAI.ChatCompletionCreateParamsNonStreaming, "model">,
-  ) => Promise<OpenAI.ChatCompletion>;
+    source: AgenticaEventSource,
+    body: Omit<OpenAI.ChatCompletionCreateParamsStreaming, "model" | "stream">,
+  ) => Promise<ReadableStream<OpenAI.Chat.Completions.ChatCompletionChunk>>;
 
   /**
    * Initialize the agent.

package/src/context/AgenticaHttpOperation.ts

@@ -0,0 +1,27 @@
+import {
+  IHttpLlmApplication,
+  IHttpLlmFunction,
+  ILlmSchema,
+} from "@samchon/openapi";
+
+import { AgenticaOperationBase } from "./AgenticaOperationBase";
+
+export class AgenticaHttpOperation<
+  Model extends ILlmSchema.Model,
+> extends AgenticaOperationBase<
+  "http",
+  IHttpLlmApplication<Model>,
+  IHttpLlmFunction<Model>
+> {
+  public constructor(props: AgenticaHttpOperation.IProps<Model>) {
+    super(props);
+  }
+}
+export namespace AgenticaHttpOperation {
+  export type IProps<Model extends ILlmSchema.Model> =
+    AgenticaOperationBase.IProps<
+      "http",
+      IHttpLlmApplication<Model>,
+      IHttpLlmFunction<Model>
+    >;
+}

package/src/{structures/IAgenticaOperation.ts → context/AgenticaOperation.ts}

@@ -1,11 +1,12 @@
 import { IHttpLlmFunction, ILlmFunction, ILlmSchema } from "@samchon/openapi";
 
-import { IAgenticaController } from "./IAgenticaController";
+import { IAgenticaOperationJson } from "../json/IAgenticaOperationJson";
+import { IAgenticaController } from "../structures/IAgenticaController";
 
 /**
- * Operation information in the Nestia Agent.
+ * Operation information in the Agentica Agent.
  *
- * `IAgenticaOperation` is a type represents an operation that would
+ * `AgenticaOperation` is a type represents an operation that would
  * be selected by the A.I. chatbot of {@link Agentica} class to
  * perform the LLM (Large Language Model) function calling.
  *
@@ -17,29 +18,26 @@ import { IAgenticaController } from "./IAgenticaController";
  *
  * @author Samchon
  */
-export type IAgenticaOperation<Model extends ILlmSchema.Model> =
-  | IAgenticaOperation.IHttp<Model>
-  | IAgenticaOperation.IClass<Model>;
-export namespace IAgenticaOperation {
-  /**
-   * HTTP API operation.
-   */
-  export type IHttp<Model extends ILlmSchema.Model> = IBase<
-    "http",
-    IAgenticaController.IHttp<Model>,
-    IHttpLlmFunction<Model>
-  >;
-
-  /**
-   * TypeScript class operation.
-   */
-  export type IClass<Model extends ILlmSchema.Model> = IBase<
+export type AgenticaOperation<Model extends ILlmSchema.Model> =
+  | AgenticaOperation.Class<Model>
+  | AgenticaOperation.Http<Model>;
+export namespace AgenticaOperation {
+  export type Class<Model extends ILlmSchema.Model> = Base<
     "class",
     IAgenticaController.IClass<Model>,
     ILlmFunction<Model>
   >;
+  export type Http<Model extends ILlmSchema.Model> = Base<
+    "http",
+    IAgenticaController.IHttp<Model>,
+    IHttpLlmFunction<Model>
+  >;
 
-  interface IBase<Protocol, Application, Function> {
+  interface Base<
+    Protocol extends "http" | "class",
+    Controller extends object,
+    Function extends object,
+  > {
     /**
      * Protocol discriminator.
      */
@@ -48,7 +46,7 @@ export namespace IAgenticaOperation {
     /**
      * Belonged controller of the target function.
      */
-    controller: Application;
+    controller: Controller;
 
     /**
      * Target function to call.
@@ -59,5 +57,10 @@ export namespace IAgenticaOperation {
      * Identifier name.
      */
     name: string;
+
+    /**
+     * Convert to primitive JSON object.
+     */
+    toJSON(): IAgenticaOperationJson;
   }
 }

package/src/context/AgenticaOperationBase.ts

@@ -0,0 +1,57 @@
+import { IAgenticaOperationJson } from "../json/IAgenticaOperationJson";
+
+export abstract class AgenticaOperationBase<
+  Protocol extends "http" | "class",
+  Controller extends object,
+  Function extends object,
+> {
+  /**
+   * Protocol discriminator.
+   */
+  public readonly protocol: Protocol;
+
+  /**
+   * Belonged controller of the target function.
+   */
+  public readonly controller: Controller;
+
+  /**
+   * Target function to call.
+   */
+  public readonly function: Function;
+
+  /**
+   * Identifier name.
+   */
+  public readonly name: string;
+
+  protected constructor(
+    props: AgenticaOperationBase.IProps<Protocol, Controller, Function>,
+  ) {
+    this.protocol = props.protocol;
+    this.controller = props.controller;
+    this.function = props.function;
+    this.name = props.name;
+  }
+
+  public toJSON(): IAgenticaOperationJson {
+    return {
+      protocol: this.protocol,
+      controller: this.controller.constructor.name,
+      function: this.function.constructor.name,
+      name: this.name,
+    };
+  }
+}
+export namespace AgenticaOperationBase {
+  export interface IProps<
+    Protocol extends "http" | "class",
+    Controller extends object,
+    Function extends object,
+  > {
+    protocol: Protocol;
+    controller: Controller;
+    function: Function;
+    name: string;
+  }
+}

package/src/{structures/IAgenticaOperationCollection.ts → context/AgenticaOperationCollection.ts}

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