@agentica/core 0.15.7 → 0.16.0

package/src/MicroAgentica.ts

@@ -0,0 +1,337 @@
+import type { ILlmSchema } from "@samchon/openapi";
+
+import type { AgenticaOperationCollection } from "./context/AgenticaOperationCollection";
+import type { MicroAgenticaContext } from "./context/MicroAgenticaContext";
+import type { AgenticaRequestEvent } from "./events/AgenticaRequestEvent";
+import type { MicroAgenticaEvent } from "./events/MicroAgenticaEvent";
+import type { AgenticaExecuteHistory } from "./histories/AgenticaExecuteHistory";
+import type { AgenticaTextHistory } from "./histories/AgenticaTextHistory";
+import type { MicroAgenticaHistory } from "./histories/MicroAgenticaHistory";
+import type { IAgenticaController } from "./structures/IAgenticaController";
+import type { IAgenticaVendor } from "./structures/IAgenticaVendor";
+import type { IMicroAgenticaConfig } from "./structures/IMicroAgenticaConfig";
+import type { IMicroAgenticaProps } from "./structures/IMicroAgenticaProps";
+
+import { AgenticaTokenUsage } from "./context/AgenticaTokenUsage";
+import { AgenticaOperationComposer } from "./context/internal/AgenticaOperationComposer";
+import { AgenticaTokenUsageAggregator } from "./context/internal/AgenticaTokenUsageAggregator";
+import { createRequestEvent, createTextEvent } from "./factory/events";
+import { createTextHistory } from "./factory/histories";
+import { call, describe } from "./orchestrate";
+import { AgenticaPromptTransformer } from "./transformers/AgenticaPromptTransformer";
+import { __map_take } from "./utils/__map_take";
+import { ChatGptCompletionMessageUtil } from "./utils/ChatGptCompletionMessageUtil";
+import { StreamUtil } from "./utils/StreamUtil";
+
+/**
+ * Micro AI chatbot.
+ *
+ * `MicroAgentica` is a facade class for the micro AI chatbot agent
+ * which performs LLM (Large Language Model) function calling from the
+ * {@link conversate user's conversation} and manages the
+ * {@link getHistories prompt histories}.
+ *
+ * Different between `MicroAgentica` and {@link Agentica} is that
+ * `MicroAgentica` does not have function selecting filter. It directly
+ * list up every functions to the agent. Besides, {@link Agentica} has
+ * a function selecting mechanism to reduce the number of functions to
+ * be listed up to the agent.
+ *
+ * Therefore, if you have a lot of functions to call, you must not
+ * use this `MicroAgentica` class. Use this `MicroAgentica` class only
+ * when you have a few functions to call.
+ *
+ * - [Multi-agent orchestration of `@agentica`](https://wrtnlabs.io/agentica/docs/concepts/function-calling/#orchestration-strategy)
+ * - Internal agents of `MicroAgentica`
+ *   - executor
+ *   - describier
+ * - Internal agents of {@link Agentica}
+ *   - initializer
+ *   - **selector**
+ *   - executor
+ *   - describer
+ *
+ * @author Samchon
+ */
+export class MicroAgentica<Model extends ILlmSchema.Model> {
+  private readonly operations_: AgenticaOperationCollection<Model>;
+  private readonly histories_: MicroAgenticaHistory<Model>[];
+  private readonly listeners_: Map<string, Set<(event: MicroAgenticaEvent<Model>) => Promise<void>>>;
+  private readonly token_usage_: AgenticaTokenUsage;
+
+  /* -----------------------------------------------------------
+    CONSTRUCTOR
+  ----------------------------------------------------------- */
+  /**
+   * Initializer Constructor.
+   *
+   * @param props Properties to construct the micro agent
+   */
+  public constructor(private readonly props: IMicroAgenticaProps<Model>) {
+    this.operations_ = AgenticaOperationComposer.compose({
+      controllers: props.controllers,
+      config: props.config,
+    });
+    this.histories_ = (props.histories ?? []).map(input =>
+      AgenticaPromptTransformer.transform({
+        operations: this.operations_.group,
+        history: input,
+      }),
+    ) as MicroAgenticaHistory<Model>[];
+    this.listeners_ = new Map();
+    this.token_usage_ = AgenticaTokenUsage.zero();
+  }
+
+  /**
+   * @internal
+   */
+  public clone(): MicroAgentica<Model> {
+    return new MicroAgentica<Model>({
+      ...this.props,
+      histories: this.props.histories?.slice(),
+    });
+  }
+
+  /* -----------------------------------------------------------
+    ACCESSORS
+  ----------------------------------------------------------- */
+  /**
+   * Conversate with the micro agent.
+   *
+   * User talks to the AI chatbot with the given content.
+   *
+   * When the user's conversation implies the AI chatbot to execute a
+   * function calling, the returned chat prompts will contain the
+   * function callinng information like {@link AgenticaExecuteHistory}
+   *
+   * @param content The content to talk
+   * @returns List of newly created histories
+   */
+  public async conversate(content: string): Promise<MicroAgenticaHistory<Model>[]> {
+    const talk: AgenticaTextHistory<"user"> = createTextHistory<"user">({
+      role: "user",
+      text: content,
+    });
+    await this.dispatch(
+      createTextEvent({
+        role: "user",
+        stream: StreamUtil.to(content),
+        done: () => true,
+        get: () => content,
+        join: async () => Promise.resolve(content),
+      }),
+    );
+
+    const ctx: MicroAgenticaContext<Model> = this.getContext({
+      prompt: talk,
+      usage: this.token_usage_,
+    });
+    const histories: MicroAgenticaHistory<Model>[] = await call(
+      ctx,
+      this.operations_.array,
+    ) as MicroAgenticaHistory<Model>[];
+    const executes: AgenticaExecuteHistory<Model>[] = histories.filter(p => p.type === "execute");
+    if (executes.length) {
+      histories.push(...await describe(ctx, executes));
+    }
+
+    this.histories_.push(talk, ...histories);
+    return histories;
+  }
+
+  /**
+   * Get configuration.
+   */
+  public getConfig(): IMicroAgenticaConfig<Model> | undefined {
+    return this.props.config;
+  }
+
+  /**
+   * Get LLM vendor.
+   */
+  public getVendor(): IAgenticaVendor {
+    return this.props.vendor;
+  }
+
+  /**
+   * Get controllers.
+   *
+   * Get list of controllers, which are the collection of functions that
+   * the agent can execute.
+   */
+  public getControllers(): ReadonlyArray<IAgenticaController<Model>> {
+    return this.props.controllers;
+  }
+
+  /**
+   * Get the chatbot's histories.
+   *
+   * Get list of chat histories that the chatbot has been conversated.
+   *
+   * @returns List of chat histories
+   */
+  public getHistories(): MicroAgenticaHistory<Model>[] {
+    return this.histories_;
+  }
+
+  /**
+   * Get token usage of the AI chatbot.
+   *
+   * Entire token usage of the AI chatbot during the conversating
+   * with the user by {@link conversate} method callings.
+   *
+   * @returns Cost of the AI chatbot
+   */
+  public getTokenUsage(): AgenticaTokenUsage {
+    return this.token_usage_;
+  }
+
+  /**
+   * @internal
+   */
+  public getContext(props: {
+    prompt: AgenticaTextHistory<"user">;
+    usage: AgenticaTokenUsage;
+  }): MicroAgenticaContext<Model> {
+    const dispatch = this.dispatch.bind(this);
+    return {
+      operations: this.operations_,
+      config: this.props.config,
+
+      histories: this.histories_,
+      prompt: props.prompt,
+      dispatch,
+      request: async (source, body) => {
+        // request information
+        const event: AgenticaRequestEvent = createRequestEvent({
+          source,
+          body: {
+            ...body,
+            model: this.props.vendor.model,
+            stream: true,
+            stream_options: {
+              include_usage: true,
+            },
+          },
+          options: this.props.vendor.options,
+        });
+        await dispatch(event);
+
+        // completion
+        const completion = await this.props.vendor.api.chat.completions.create(
+          event.body,
+          event.options,
+        );
+
+        const [streamForEvent, temporaryStream] = StreamUtil.transform(
+          completion.toReadableStream() as ReadableStream<Uint8Array>,
+          value =>
+            ChatGptCompletionMessageUtil.transformCompletionChunk(value),
+        ).tee();
+
+        const [streamForAggregate, streamForReturn] = temporaryStream.tee();
+
+        void (async () => {
+          const reader = streamForAggregate.getReader();
+          while (true) {
+            const chunk = await reader.read();
+            if (chunk.done) {
+              break;
+            }
+            if (chunk.value.usage != null) {
+              AgenticaTokenUsageAggregator.aggregate({
+                kind: source,
+                completionUsage: chunk.value.usage,
+                usage: props.usage,
+              });
+            }
+          }
+        })();
+
+        const [streamForStream, streamForJoin] = streamForEvent.tee();
+        await dispatch({
+          type: "response",
+          source,
+          stream: streamForStream,
+          body: event.body,
+          options: event.options,
+          join: async () => {
+            const chunks = await StreamUtil.readAll(streamForJoin);
+            return ChatGptCompletionMessageUtil.merge(chunks);
+          },
+        });
+
+        return streamForReturn;
+      },
+    };
+  }
+
+  /* -----------------------------------------------------------
+      EVENT HANDLERS
+    ----------------------------------------------------------- */
+  /**
+   * Add an event listener.
+   *
+   * Add an event listener to be called whenever the event is emitted.
+   *
+   * @param type Type of event
+   * @param listener Callback function to be called whenever the event is emitted
+   */
+  public on<Type extends MicroAgenticaEvent.Type>(
+    type: Type,
+    listener: (
+      event: MicroAgenticaEvent.Mapper<Model>[Type],
+    ) => void | Promise<void>,
+  ): this {
+    /**
+     * @TODO remove `as`
+     */
+    __map_take(this.listeners_, type, () => new Set()).add(listener as (event: MicroAgenticaEvent<Model>) => Promise<void>);
+    return this;
+  }
+
+  /**
+   * Erase an event listener.
+   *
+   * Erase an event listener to stop calling the callback function.
+   *
+   * @param type Type of event
+   * @param listener Callback function to erase
+   */
+  public off<Type extends MicroAgenticaEvent.Type>(
+    type: Type,
+    listener: (
+      event: MicroAgenticaEvent.Mapper<Model>[Type],
+    ) => void | Promise<void>,
+  ): this {
+    const set = this.listeners_.get(type);
+    if (set !== undefined) {
+      /**
+       * @TODO remove `as`
+       */
+      set.delete(listener as (event: MicroAgenticaEvent<Model>) => Promise<void>);
+      if (set.size === 0) {
+        this.listeners_.delete(type);
+      }
+    }
+    return this;
+  }
+
+  private async dispatch<Event extends MicroAgenticaEvent<Model>>(
+    event: Event,
+  ): Promise<void> {
+    const set = this.listeners_.get(event.type);
+    if (set !== undefined) {
+      await Promise.all(
+        Array.from(set).map(async (listener) => {
+          try {
+            await listener(event);
+          }
+          catch {
+            /* empty */
+          }
+        }),
+      );
+    }
+  }
+}

package/src/constants/AgenticaDefaultPrompt.ts

@@ -1,6 +1,8 @@
 import type { ILlmSchema } from "@samchon/openapi";
 
 import type { IAgenticaConfig } from "../structures/IAgenticaConfig";
+import type { IMicroAgenticaConfig } from "../structures/IMicroAgenticaConfig";
+import type { IMicroAgenticaSystemPrompt } from "../structures/IMicroAgenticaSystemPrompt";
 
 import { Singleton } from "../utils/Singleton";
 
@@ -39,9 +41,9 @@ const getTimezone = new Singleton(
   () => Intl.DateTimeFormat().resolvedOptions().timeZone,
 );
 
-export function write<Model extends ILlmSchema.Model>(config?: IAgenticaConfig<Model>): string {
+export function write<Model extends ILlmSchema.Model>(config?: IAgenticaConfig<Model> | IMicroAgenticaConfig<Model>): string {
   if (config?.systemPrompt?.common !== undefined) {
-    return config?.systemPrompt?.common(config);
+    return (config.systemPrompt as IMicroAgenticaSystemPrompt<Model>).common!(config as unknown as IMicroAgenticaConfig<Model>);
   }
 
   const locale: string = config?.locale ?? getLocale.get();

package/src/context/AgenticaCancelPrompt.ts

@@ -1,13 +1,13 @@
 import type { ILlmSchema } from "@samchon/openapi";
 
-import type { IAgenticaPromptJson } from "../json/IAgenticaPromptJson";
-import type { AgenticaPromptBase } from "../prompts/AgenticaPromptBase";
+import type { AgenticaHistoryBase } from "../histories/AgenticaHistoryBase";
+import type { IAgenticaHistoryJson } from "../json/IAgenticaHistoryJson";
 
 import type { AgenticaOperationSelection } from "./AgenticaOperationSelection";
 
 export interface AgenticaCancelPrompt<
   Model extends ILlmSchema.Model,
-> extends AgenticaPromptBase<"cancel", IAgenticaPromptJson.ICancel> {
+> extends AgenticaHistoryBase<"cancel", IAgenticaHistoryJson.ICancel> {
   id: string;
   selections: AgenticaOperationSelection<Model>[];
 }

package/src/context/AgenticaContext.ts

@@ -3,28 +3,28 @@ import type OpenAI from "openai";
 
 import type { AgenticaEvent } from "../events/AgenticaEvent";
 import type { AgenticaEventSource } from "../events/AgenticaEventSource";
-import type { AgenticaPrompt } from "../prompts/AgenticaPrompt";
-import type { AgenticaTextPrompt } from "../prompts/AgenticaTextPrompt";
+import type { AgenticaHistory } from "../histories/AgenticaHistory";
+import type { AgenticaTextHistory } from "../histories/AgenticaTextHistory";
 import type { IAgenticaConfig } from "../structures/IAgenticaConfig";
 
 import type { AgenticaOperationCollection } from "./AgenticaOperationCollection";
 import type { AgenticaOperationSelection } from "./AgenticaOperationSelection";
 
 /**
- * Context of the Nestia A.I. agent.
+ * Context of the Agentic AI agent.
  *
- * `IAgenticaContext` is a structure defining the context of the
+ * `AgenticaContext` is a structure defining the context of the
  * internal agents composing the {@link Agentica}, like function
  * selector, executor, and describer, and so on. For example, if an
  * agent has been configured to utilize the OpenAI, the context will
  * be delivered to the below components.
  *
- * - {@link ChatGptAgent}
- *   - {@link ChatGptInitializeFunctionAgent}
- *   - {@link ChatGptSelectFunctionAgent}
- *   - {@link ChatGptExecuteFunctionAgent}
- *   - {@link ChatGptDescribeFunctionAgent}
- *   - {@link ChatGptCancelFunctionAgent}
+ * - {@link orchestrate.execute}
+ *   - {@link orchestrate.initialize}
+ *   - {@link orchestrate.select}
+ *   - {@link orchestrate.call}
+ *   - {@link orchestrate.describe}
+ *   - {@link orchestrate.cancel}
  *
  * Also, as its name is context, it contains every information that
  * is required to interact with the AI vendor like OpenAI. It
@@ -70,7 +70,7 @@ export interface AgenticaContext<Model extends ILlmSchema.Model> {
   /**
    * Prompt histories.
    */
-  histories: AgenticaPrompt<Model>[];
+  histories: AgenticaHistory<Model>[];
 
   /**
    * Stacked operations.
@@ -85,7 +85,7 @@ export interface AgenticaContext<Model extends ILlmSchema.Model> {
    * Text conversation written the by user through the
    * {@link Agentica.conversate} function.
    */
-  prompt: AgenticaTextPrompt<"user">;
+  prompt: AgenticaTextHistory<"user">;
 
   /**
    * Whether the agent is ready.

package/src/context/AgenticaOperationCollection.ts

@@ -3,7 +3,7 @@ import type { ILlmSchema } from "@samchon/openapi";
 import type { AgenticaOperation } from "./AgenticaOperation";
 
 /**
- * Collection of operations used in the Nestia Agent.
+ * Collection of operations used in the Agentica Agent.
  *
  * `IAgenticaOperationCollection` is an interface type representing
  * a collection of operations for several purposes used in the

package/src/context/MicroAgenticaContext.ts

@@ -0,0 +1,95 @@
+import type { ILlmSchema } from "@samchon/openapi";
+import type OpenAI from "openai";
+
+import type { MicroAgenticaEvent } from "../events/MicroAgenticaEvent";
+import type { AgenticaTextHistory } from "../histories/AgenticaTextHistory";
+import type { MicroAgenticaHistory } from "../histories/MicroAgenticaHistory";
+import type { IMicroAgenticaConfig } from "../structures/IMicroAgenticaConfig";
+
+import type { AgenticaOperationCollection } from "./AgenticaOperationCollection";
+
+/**
+ * Context of the Micro Agentic AI agent.
+ *
+ * `MicroAgenticaContext` is a structure defining the context of the
+ * internal agents composing the {@link MicroAgentica}.
+ *
+ * It contains every information that is required to interact with
+ * the AI vendor like OpenAI. It contains every operations for LLM
+ * function calling, and configuration used for the agent construction.
+ * And it contains the prompt histories, and facade controller
+ * functions for interacting with the {@link MicroAgentica} like
+ * {@link dispatch}.
+ *
+ * In such reasons, if you're planning to customize some internal
+ * agents, or add new agents with new process routine, you have to
+ * understand this context structure. Otherwise you don't have any
+ * plan to customize the internal agents, this context information is
+ * not important for you.
+ *
+ * @author Samchon
+ */
+export interface MicroAgenticaContext<Model extends ILlmSchema.Model> {
+  // ----
+  // APPLICATION
+  // ----
+  /**
+   * Collection of operations.
+   *
+   * Collection of operations from every controllers, and their
+   * groups composed by the divide and conquer rule for the
+   * efficient operation selection if configured.
+   */
+  operations: AgenticaOperationCollection<Model>;
+
+  /**
+   * Configuration of the agent.
+   *
+   * Configuration of the agent, that is used when constructing the
+   * {@link Agentica} instance.
+   *
+   * @todo Write detaily after supporting the agent customization feature
+   */
+  config: IMicroAgenticaConfig<Model> | undefined;
+
+  // ----
+  // STATES
+  // ----
+  /**
+   * Prompt histories.
+   */
+  histories: MicroAgenticaHistory<Model>[];
+
+  /**
+   * Text prompt of the user.
+   *
+   * Text conversation written the by user through the
+   * {@link Agentica.conversate} function.
+   */
+  prompt: AgenticaTextHistory<"user">;
+
+  // ----
+  // HANDLERS
+  // ----
+  /**
+   * Dispatch event.
+   *
+   * Dispatch event so that the agent can be handle the event
+   * through the {@link Agentica.on} function.
+   *
+   * @param event Event to deliver
+   */
+  dispatch: (event: MicroAgenticaEvent<Model>) => Promise<void>;
+
+  /**
+   * Request to the OpenAI server.
+   *
+   * @param source The source agent of the agent
+   * @param body The request body to the OpenAI server
+   * @returns Response from the OpenAI server
+   */
+  request: (
+    source: MicroAgenticaEvent.Source,
+    body: Omit<OpenAI.ChatCompletionCreateParamsStreaming, "model" | "stream">,
+  ) => Promise<ReadableStream<OpenAI.Chat.Completions.ChatCompletionChunk>>;
+}

package/src/context/internal/AgenticaOperationComposer.ts

@@ -2,6 +2,7 @@ import type { ILlmSchema } from "@samchon/openapi";
 
 import type { IAgenticaConfig } from "../../structures/IAgenticaConfig";
 import type { IAgenticaController } from "../../structures/IAgenticaController";
+import type { IMicroAgenticaConfig } from "../../structures/IMicroAgenticaConfig";
 import type { AgenticaOperation } from "../AgenticaOperation";
 import type { AgenticaOperationCollection } from "../AgenticaOperationCollection";
 
@@ -9,7 +10,7 @@ import { __map_take } from "../../utils/__map_take";
 
 export function compose<Model extends ILlmSchema.Model>(props: {
   controllers: IAgenticaController<Model>[];
-  config?: IAgenticaConfig<Model> | undefined;
+  config?: IAgenticaConfig<Model> | IMicroAgenticaConfig<Model> | undefined;
 }): AgenticaOperationCollection<Model> {
   const unique: boolean
       = props.controllers.length === 1
@@ -59,11 +60,13 @@ export function compose<Model extends ILlmSchema.Model>(props: {
           ),
     )
     .flat();
+
+  const capacity: number | undefined = (props.config as IAgenticaConfig<Model>)?.capacity;
   const divided: AgenticaOperation<Model>[][] | undefined
-      = props.config?.capacity !== undefined && array.length > props.config.capacity
+      = capacity !== undefined && array.length > capacity
         ? divide({
             array,
-            capacity: props.config.capacity,
+            capacity,
           })
         : undefined;
 

package/src/context/internal/isAgenticaContext.ts

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

package/src/events/AgenticaDescribeEvent.ts

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

package/src/events/AgenticaEvent.ts

@@ -46,4 +46,10 @@ export namespace AgenticaEvent {
     text: AgenticaTextEvent;
     validate: AgenticaValidateEvent<Model>;
   }
+  export type Source =
+    | "initialize"
+    | "select"
+    | "cancel"
+    | "call"
+    | "describe";
 }

package/src/events/AgenticaExecuteEvent.ts

@@ -1,8 +1,8 @@
 import type { IHttpResponse, ILlmSchema } from "@samchon/openapi";
 
 import type { AgenticaOperation } from "../context/AgenticaOperation";
+import type { AgenticaExecuteHistory } from "../histories/AgenticaExecuteHistory";
 import type { IAgenticaEventJson } from "../json/IAgenticaEventJson";
-import type { AgenticaExecutePrompt } from "../prompts/AgenticaExecutePrompt";
 
 import type { AgenticaEventBase } from "./AgenticaEventBase";
 
@@ -14,7 +14,7 @@ export namespace AgenticaExecuteEvent {
     extends Base<
       "class",
       AgenticaOperation.Class<Model>,
-      AgenticaExecutePrompt.Class<Model>,
+      AgenticaExecuteHistory.Class<Model>,
       unknown
     > {}
 
@@ -22,14 +22,14 @@ export namespace AgenticaExecuteEvent {
     extends Base<
       "http",
       AgenticaOperation.Http<Model>,
-      AgenticaExecutePrompt.Http<Model>,
+      AgenticaExecuteHistory.Http<Model>,
       IHttpResponse
     > {}
 
   interface Base<
     Protocol extends "http" | "class",
     Operation extends AgenticaOperation<any>,
-    Prompt extends AgenticaExecutePrompt<any>,
+    History extends AgenticaExecuteHistory<any>,
     Value,
   > extends AgenticaEventBase<"execute"> {
     protocol: Protocol;
@@ -39,6 +39,6 @@ export namespace AgenticaExecuteEvent {
     value: Value;
 
     toJSON: () => IAgenticaEventJson.IExecute;
-    toPrompt: () => Prompt;
+    toHistory: () => History;
   }
 }

package/src/events/AgenticaSelectEvent.ts

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