@agentica/core 0.23.0 → 0.25.0

package/src/MicroAgentica.ts

@@ -5,8 +5,9 @@ import type { AgenticaOperationCollection } from "./context/AgenticaOperationCol
 import type { MicroAgenticaContext } from "./context/MicroAgenticaContext";
 import type { AgenticaRequestEvent } from "./events/AgenticaRequestEvent";
 import type { MicroAgenticaEvent } from "./events/MicroAgenticaEvent";
+import type { AgenticaUserMessageContent } from "./histories";
 import type { AgenticaExecuteHistory } from "./histories/AgenticaExecuteHistory";
-import type { AgenticaUserInputHistory } from "./histories/AgenticaUserInputHistory";
+import type { AgenticaUserMessageHistory } from "./histories/AgenticaUserMessageHistory";
 import type { MicroAgenticaHistory } from "./histories/MicroAgenticaHistory";
 import type { IAgenticaController } from "./structures/IAgenticaController";
 import type { IAgenticaVendor } from "./structures/IAgenticaVendor";
@@ -16,10 +17,10 @@ import type { IMicroAgenticaProps } from "./structures/IMicroAgenticaProps";
 import { AgenticaTokenUsage } from "./context/AgenticaTokenUsage";
 import { AgenticaOperationComposer } from "./context/internal/AgenticaOperationComposer";
 import { AgenticaTokenUsageAggregator } from "./context/internal/AgenticaTokenUsageAggregator";
-import { createUserInputHistory } from "./factory";
-import { createRequestEvent, createUserInputEvent } from "./factory/events";
+import { createUserMessageHistory } from "./factory";
+import { createRequestEvent, createUserMessageEvent } from "./factory/events";
 import { call, describe } from "./orchestrate";
-import { AgenticaHistoryTransformer } from "./transformers/AgenticaHistoryTransformer";
+import { transformHistory } from "./transformers/transformHistory";
 import { __map_take } from "./utils/__map_take";
 import { ChatGptCompletionMessageUtil } from "./utils/ChatGptCompletionMessageUtil";
 import { streamDefaultReaderToAsyncGenerator, StreamUtil } from "./utils/StreamUtil";
@@ -74,7 +75,7 @@ export class MicroAgentica<Model extends ILlmSchema.Model> {
       config: props.config,
     });
     this.histories_ = (props.histories ?? []).map(input =>
-      AgenticaHistoryTransformer.transform({
+      transformHistory({
         operations: this.operations_.group,
         history: input,
       }),
@@ -108,8 +109,10 @@ export class MicroAgentica<Model extends ILlmSchema.Model> {
    * @param content The content to talk
    * @returns List of newly created histories
    */
-  public async conversate(content: string | AgenticaUserInputHistory.Contents | Array<AgenticaUserInputHistory.Contents>): Promise<MicroAgenticaHistory<Model>[]> {
-    const talk = createUserInputHistory({
+  public async conversate(
+    content: string | AgenticaUserMessageContent | Array<AgenticaUserMessageContent>,
+  ): Promise<MicroAgenticaHistory<Model>[]> {
+    const talk = createUserMessageHistory({
       contents: Array.isArray(content)
         ? content
         : typeof content === "string"
@@ -120,7 +123,7 @@ export class MicroAgentica<Model extends ILlmSchema.Model> {
           : [content],
     });
     this.dispatch(
-      createUserInputEvent({
+      createUserMessageEvent({
         contents: talk.contents,
       }),
     ).catch(() => {});
@@ -207,7 +210,7 @@ export class MicroAgentica<Model extends ILlmSchema.Model> {
    * @internal
    */
   public getContext(props: {
-    prompt: AgenticaUserInputHistory;
+    prompt: AgenticaUserMessageHistory;
     usage: AgenticaTokenUsage;
   }): MicroAgenticaContext<Model> {
     const dispatch = this.dispatch.bind(this);

package/src/context/AgenticaContext.ts

@@ -4,7 +4,7 @@ import type OpenAI from "openai";
 import type { AgenticaEvent } from "../events/AgenticaEvent";
 import type { AgenticaEventSource } from "../events/AgenticaEventSource";
 import type { AgenticaHistory } from "../histories/AgenticaHistory";
-import type { AgenticaUserInputHistory } from "../histories/AgenticaUserInputHistory";
+import type { AgenticaUserMessageHistory } from "../histories/AgenticaUserMessageHistory";
 import type { IAgenticaConfig } from "../structures/IAgenticaConfig";
 
 import type { AgenticaOperationCollection } from "./AgenticaOperationCollection";
@@ -85,7 +85,12 @@ export interface AgenticaContext<Model extends ILlmSchema.Model> {
    * The user input history written by the user through the
    * {@link Agentica.conversate} function.
    */
-  prompt: AgenticaUserInputHistory;
+  prompt: AgenticaUserMessageHistory;
+
+  /**
+   * Abort signal.
+   */
+  abortSignal?: AbortSignal;
 
   /**
    * Whether the agent is ready.

package/src/context/MicroAgenticaContext.ts

@@ -2,7 +2,7 @@ import type { ILlmSchema } from "@samchon/openapi";
 import type OpenAI from "openai";
 
 import type { MicroAgenticaEvent } from "../events/MicroAgenticaEvent";
-import type { AgenticaUserInputHistory } from "../histories/AgenticaUserInputHistory";
+import type { AgenticaUserMessageHistory } from "../histories/AgenticaUserMessageHistory";
 import type { MicroAgenticaHistory } from "../histories/MicroAgenticaHistory";
 import type { IMicroAgenticaConfig } from "../structures/IMicroAgenticaConfig";
 
@@ -66,7 +66,7 @@ export interface MicroAgenticaContext<Model extends ILlmSchema.Model> {
    * Text conversation written the by user through the
    * {@link Agentica.conversate} function.
    */
-  prompt: AgenticaUserInputHistory;
+  prompt: AgenticaUserMessageHistory;
 
   // ----
   // HANDLERS

package/src/context/index.ts

@@ -0,0 +1,5 @@
+export * from "./AgenticaContext";
+export * from "./AgenticaOperation";
+export * from "./AgenticaOperationCollection";
+export * from "./AgenticaOperationSelection";
+export * from "./AgenticaTokenUsage";

package/src/events/AgenticaAssistantMessageEvent.ts

@@ -0,0 +1,12 @@
+import type { AgenticaAssistantMessageHistory } from "../histories/AgenticaAssistantMessageHistory";
+import type { IAgenticaEventJson } from "../json/IAgenticaEventJson";
+
+import type { AgenticaEventBase } from "./AgenticaEventBase";
+
+export interface AgenticaAssistantMessageEvent
+  extends AgenticaEventBase<"assistantMessage"> {
+  stream: AsyncGenerator<string, undefined, undefined>;
+  join: () => Promise<string>;
+  toJSON: () => IAgenticaEventJson.IAssistantMessage;
+  toHistory: () => AgenticaAssistantMessageHistory;
+}

package/src/events/AgenticaEvent.ts

@@ -1,5 +1,6 @@
 import type { ILlmSchema } from "@samchon/openapi";
 
+import type { AgenticaAssistantMessageEvent } from "./AgenticaAssistantMessageEvent";
 import type { AgenticaCallEvent } from "./AgenticaCallEvent";
 import type { AgenticaCancelEvent } from "./AgenticaCancelEvent";
 import type { AgenticaDescribeEvent } from "./AgenticaDescribeEvent";
@@ -8,8 +9,7 @@ import type { AgenticaInitializeEvent } from "./AgenticaInitializeEvent";
 import type { AgenticaRequestEvent } from "./AgenticaRequestEvent";
 import type { AgenticaResponseEvent } from "./AgenticaResponseEvent";
 import type { AgenticaSelectEvent } from "./AgenticaSelectEvent";
-import type { AgenticaTextEvent } from "./AgenticaTextEvent";
-import type { AgenticaUserInputEvent } from "./AgenticaUserInputEvent";
+import type { AgenticaUserMessageEvent } from "./AgenticaUserMessageEvent";
 import type { AgenticaValidateEvent } from "./AgenticaValidateEvent";
 
 /**
@@ -23,31 +23,31 @@ import type { AgenticaValidateEvent } from "./AgenticaValidateEvent";
  * @author Samchon
  */
 export type AgenticaEvent<Model extends ILlmSchema.Model> =
+  | AgenticaUserMessageEvent
+  | AgenticaAssistantMessageEvent
+  | AgenticaInitializeEvent
+  | AgenticaSelectEvent<Model>
   | AgenticaCallEvent<Model>
   | AgenticaCancelEvent<Model>
-  | AgenticaDescribeEvent<Model>
   | AgenticaExecuteEvent<Model>
-  | AgenticaInitializeEvent
-  | AgenticaRequestEvent
-  | AgenticaResponseEvent
-  | AgenticaSelectEvent<Model>
-  | AgenticaTextEvent
+  | AgenticaDescribeEvent<Model>
   | AgenticaValidateEvent<Model>
-  | AgenticaUserInputEvent;
+  | AgenticaRequestEvent
+  | AgenticaResponseEvent;
 export namespace AgenticaEvent {
   export type Type = AgenticaEvent<any>["type"];
   export interface Mapper<Model extends ILlmSchema.Model> {
+    userMessage: AgenticaUserMessageEvent;
+    assistantMessage: AgenticaAssistantMessageEvent;
+    select: AgenticaSelectEvent<Model>;
+    initialize: AgenticaInitializeEvent;
     call: AgenticaCallEvent<Model>;
     cancel: AgenticaCancelEvent<Model>;
-    describe: AgenticaDescribeEvent<Model>;
     execute: AgenticaExecuteEvent<Model>;
-    initialize: AgenticaInitializeEvent;
+    describe: AgenticaDescribeEvent<Model>;
+    validate: AgenticaValidateEvent<Model>;
     request: AgenticaRequestEvent;
     response: AgenticaResponseEvent;
-    select: AgenticaSelectEvent<Model>;
-    text: AgenticaTextEvent;
-    validate: AgenticaValidateEvent<Model>;
-    user_input: AgenticaUserInputEvent;
   }
   export type Source =
     | "initialize"

package/src/events/AgenticaUserMessageEvent.ts

@@ -0,0 +1,12 @@
+import type { AgenticaUserMessageContent } from "../histories";
+import type { AgenticaUserMessageHistory } from "../histories/AgenticaUserMessageHistory";
+import type { IAgenticaEventJson } from "../json/IAgenticaEventJson";
+
+import type { AgenticaEventBase } from "./AgenticaEventBase";
+
+export interface AgenticaUserMessageEvent
+  extends AgenticaEventBase<"userMessage"> {
+  contents: Array<AgenticaUserMessageContent>;
+  toJSON: () => IAgenticaEventJson.IUserMessage;
+  toHistory: () => AgenticaUserMessageHistory;
+}

package/src/events/MicroAgenticaEvent.ts

@@ -1,12 +1,12 @@
 import type { ILlmSchema } from "@samchon/openapi";
 
+import type { AgenticaAssistantMessageEvent } from "./AgenticaAssistantMessageEvent";
 import type { AgenticaCallEvent } from "./AgenticaCallEvent";
 import type { AgenticaDescribeEvent } from "./AgenticaDescribeEvent";
 import type { AgenticaExecuteEvent } from "./AgenticaExecuteEvent";
 import type { AgenticaRequestEvent } from "./AgenticaRequestEvent";
 import type { AgenticaResponseEvent } from "./AgenticaResponseEvent";
-import type { AgenticaTextEvent } from "./AgenticaTextEvent";
-import type { AgenticaUserInputEvent } from "./AgenticaUserInputEvent";
+import type { AgenticaUserMessageEvent } from "./AgenticaUserMessageEvent";
 import type { AgenticaValidateEvent } from "./AgenticaValidateEvent";
 
 /**
@@ -20,25 +20,25 @@ import type { AgenticaValidateEvent } from "./AgenticaValidateEvent";
  * @author Samchon
  */
 export type MicroAgenticaEvent<Model extends ILlmSchema.Model> =
+  | AgenticaUserMessageEvent
+  | AgenticaAssistantMessageEvent
   | AgenticaCallEvent<Model>
-  | AgenticaDescribeEvent<Model>
   | AgenticaExecuteEvent<Model>
+  | AgenticaDescribeEvent<Model>
   | AgenticaRequestEvent
   | AgenticaResponseEvent
-  | AgenticaTextEvent
-  | AgenticaValidateEvent<Model>
-  | AgenticaUserInputEvent;
+  | AgenticaValidateEvent<Model>;
 export namespace MicroAgenticaEvent {
   export type Type = MicroAgenticaEvent<any>["type"];
   export interface Mapper<Model extends ILlmSchema.Model> {
+    userMessage: AgenticaUserMessageEvent;
+    assistantMessage: AgenticaAssistantMessageEvent;
     call: AgenticaCallEvent<Model>;
-    describe: AgenticaDescribeEvent<Model>;
     execute: AgenticaExecuteEvent<Model>;
+    describe: AgenticaDescribeEvent<Model>;
     request: AgenticaRequestEvent;
     response: AgenticaResponseEvent;
-    text: AgenticaTextEvent;
     validate: AgenticaValidateEvent<Model>;
-    user_input: AgenticaUserInputEvent;
   }
   export type Source = "call" | "describe";
 }

package/src/events/index.ts

@@ -0,0 +1,14 @@
+export * from "./AgenticaAssistantMessageEvent";
+export * from "./AgenticaCallEvent";
+export * from "./AgenticaCancelEvent";
+export * from "./AgenticaDescribeEvent";
+export * from "./AgenticaEvent";
+export * from "./AgenticaEventSource";
+export * from "./AgenticaExecuteEvent";
+export * from "./AgenticaInitializeEvent";
+export * from "./AgenticaRequestEvent";
+export * from "./AgenticaResponseEvent";
+export * from "./AgenticaSelectEvent";
+export * from "./AgenticaUserMessageEvent";
+export * from "./AgenticaValidateEvent";
+export * from "./MicroAgenticaEvent";

package/src/factory/events.ts

@@ -5,6 +5,7 @@ import { v4 } from "uuid";
 
 import type { AgenticaOperation } from "../context/AgenticaOperation";
 import type { AgenticaOperationSelection } from "../context/AgenticaOperationSelection";
+import type { AgenticaAssistantMessageEvent } from "../events/AgenticaAssistantMessageEvent";
 import type { AgenticaCallEvent } from "../events/AgenticaCallEvent";
 import type { AgenticaCancelEvent } from "../events/AgenticaCancelEvent";
 import type { AgenticaDescribeEvent } from "../events/AgenticaDescribeEvent";
@@ -14,14 +15,13 @@ import type { AgenticaInitializeEvent } from "../events/AgenticaInitializeEvent"
 import type { AgenticaRequestEvent } from "../events/AgenticaRequestEvent";
 import type { AgenticaResponseEvent } from "../events/AgenticaResponseEvent";
 import type { AgenticaSelectEvent } from "../events/AgenticaSelectEvent";
-import type { AgenticaTextEvent } from "../events/AgenticaTextEvent";
-import type { AgenticaUserInputEvent } from "../events/AgenticaUserInputEvent";
+import type { AgenticaUserMessageEvent } from "../events/AgenticaUserMessageEvent";
 import type { AgenticaValidateEvent } from "../events/AgenticaValidateEvent";
+import type { AgenticaUserMessageContent } from "../histories";
 import type { AgenticaExecuteHistory } from "../histories/AgenticaExecuteHistory";
-import type { AgenticaUserInputHistory } from "../histories/AgenticaUserInputHistory";
 import type { IAgenticaEventJson } from "../json/IAgenticaEventJson";
 
-import { createExecuteHistory, createSelectHistory, createUserInputHistory } from "./histories";
+import { createExecuteHistory, createSelectHistory, createUserMessageHistory } from "./histories";
 
 /* -----------------------------------------------------------
   FUNCTION SELECTS
@@ -36,23 +36,6 @@ export function createInitializeEvent(): AgenticaInitializeEvent {
   };
 }
 
-export function createUserInputEvent(props: {
-  contents: Array<AgenticaUserInputHistory.Contents>;
-}): AgenticaUserInputEvent {
-  return {
-    type: "user_input",
-    role: "user",
-    contents: props.contents,
-    join: async () => props.contents,
-    toJSON: () => ({
-      type: "user_input",
-      contents: props.contents,
-    }),
-    toHistory: () => createUserInputHistory({
-      contents: props.contents,
-    }),
-  };
-}
 export function createSelectEvent<Model extends ILlmSchema.Model>(props: {
   selection: AgenticaOperationSelection<Model>;
 }): AgenticaSelectEvent<Model> {
@@ -151,32 +134,44 @@ export function createExecuteEvent<Model extends ILlmSchema.Model>(props: {
 }
 
 /* -----------------------------------------------------------
-  TEXT STEAMING
+  CONTENTS
 ----------------------------------------------------------- */
-export function createTextEvent(props: {
+export function createUserMessageEvent(props: {
+  contents: Array<AgenticaUserMessageContent>;
+}): AgenticaUserMessageEvent {
+  return {
+    type: "userMessage",
+    contents: props.contents,
+    toJSON: () => ({
+      type: "userMessage",
+      contents: props.contents,
+    }),
+    toHistory: () => createUserMessageHistory({
+      contents: props.contents,
+    }),
+  };
+}
+
+export function creatAssistantEvent(props: {
   stream: AsyncGenerator<string, undefined, undefined>;
   done: () => boolean;
   get: () => string;
   join: () => Promise<string>;
-}): AgenticaTextEvent {
+}): AgenticaAssistantMessageEvent {
   return {
-    type: "text",
-    role: "assistant",
+    type: "assistantMessage",
     stream: props.stream,
     join: props.join,
     toJSON: () => ({
-      type: "text",
-      role: "assistant",
+      type: "assistantMessage",
       done: props.done(),
       text: props.get(),
     }),
     toHistory: () => ({
-      type: "text",
-      role: "assistant",
+      type: "assistantMessage",
       text: props.get(),
       toJSON: () => ({
-        type: "text",
-        role: "assistant",
+        type: "assistantMessage",
         text: props.get(),
       }),
     }),
@@ -215,8 +210,8 @@ export function createDescribeEvent<Model extends ILlmSchema.Model>(props: {
 }
 
 /* -----------------------------------------------------------
-    API REQUESTS
-  ----------------------------------------------------------- */
+  API REQUESTS
+----------------------------------------------------------- */
 export function createRequestEvent(props: {
   source: AgenticaEventSource;
   body: OpenAI.ChatCompletionCreateParamsStreaming;

package/src/factory/histories.ts

@@ -3,31 +3,25 @@ import type OpenAI from "openai";
 
 import type { AgenticaOperation } from "../context/AgenticaOperation";
 import type { AgenticaOperationSelection } from "../context/AgenticaOperationSelection";
+import type { AgenticaUserMessageContent } from "../histories";
+import type { AgenticaAssistantMessageHistory } from "../histories/AgenticaAssistantMessageHistory";
 import type { AgenticaCancelHistory } from "../histories/AgenticaCancelHistory";
 import type { AgenticaDescribeHistory } from "../histories/AgenticaDescribeHistory";
 import type { AgenticaExecuteHistory } from "../histories/AgenticaExecuteHistory";
 import type { AgenticaHistory } from "../histories/AgenticaHistory";
 import type { AgenticaSelectHistory } from "../histories/AgenticaSelectHistory";
-import type { AgenticaTextHistory } from "../histories/AgenticaTextHistory";
-import type { AgenticaUserInputHistory } from "../histories/AgenticaUserInputHistory";
+import type { AgenticaUserMessageHistory } from "../histories/AgenticaUserMessageHistory";
 import type { IAgenticaHistoryJson } from "../json/IAgenticaHistoryJson";
 
+/**
+ * @internal
+ */
 export function decodeHistory<Model extends ILlmSchema.Model>(history: AgenticaHistory<Model>): OpenAI.ChatCompletionMessageParam[] {
   // NO NEED TO DECODE DESCRIBE
   if (history.type === "describe") {
     return [];
   }
-
-  if (history.type === "text") {
-    return [
-      {
-        role: history.role,
-        content: history.text,
-      },
-    ];
-  }
-
-  if (history.type === "select" || history.type === "cancel") {
+  else if (history.type === "select" || history.type === "cancel") {
     return [
       {
         role: "assistant",
@@ -54,8 +48,7 @@ export function decodeHistory<Model extends ILlmSchema.Model>(history: AgenticaH
       },
     ];
   }
-
-  if (history.type === "execute") {
+  else if (history.type === "execute") {
     return [
       {
         role: "assistant",
@@ -98,32 +91,74 @@ export function decodeHistory<Model extends ILlmSchema.Model>(history: AgenticaH
       },
     ];
   }
-
-  if (history.type === "user_input") {
+  else if (history.type === "assistantMessage") {
     return [
       {
-        role: "user",
-        content: history.contents,
+        role: "assistant",
+        content: history.text,
       },
     ];
   }
+  return [
+    {
+      role: "user",
+      content: history.contents.map(decodeUserMessageContent),
+    },
+  ];
+}
 
-  history satisfies never;
-  throw new Error("Invalid history type");
+/**
+ * @internal
+ */
+export function decodeUserMessageContent(content: AgenticaUserMessageContent): OpenAI.ChatCompletionContentPart {
+  if (content.type === "audio") {
+    return {
+      type: "input_audio",
+      input_audio: {
+        data: content.data,
+        format: content.format,
+      },
+    };
+  }
+  else if (content.type === "file") {
+    return {
+      type: "file",
+      file: content.file.type === "data"
+        ? {
+            file_data: content.file.data,
+            filename: content.file.name,
+          }
+        : {
+            file_id: content.file.id,
+          },
+    };
+  }
+  else if (content.type === "image") {
+    return {
+      type: "image_url",
+      image_url: {
+        url: content.url,
+        detail: content.detail,
+      },
+    };
+  }
+  return content;
 }
 
 /* -----------------------------------------------------------
   USER INPUT PROMPTS
 ----------------------------------------------------------- */
-export function createUserInputHistory(props: {
-  contents: Array<AgenticaUserInputHistory.Contents>;
-}): AgenticaUserInputHistory {
+/**
+ * @internal
+ */
+export function createUserMessageHistory(props: {
+  contents: Array<AgenticaUserMessageContent>;
+}): AgenticaUserMessageHistory {
   return {
-    type: "user_input",
-    role: "user",
+    type: "userMessage",
     contents: props.contents,
     toJSON: () => ({
-      type: "user_input",
+      type: "userMessage",
       contents: props.contents,
     }),
   };
@@ -132,12 +167,14 @@ export function createUserInputHistory(props: {
 /* -----------------------------------------------------------
   TEXT PROMPTS
 ----------------------------------------------------------- */
-export function createTextHistory(props: {
+/**
+ * @internal
+ */
+export function createAssistantMessageHistory(props: {
   text: string;
-}): AgenticaTextHistory {
-  const prompt: IAgenticaHistoryJson.IText = {
-    type: "text",
-    role: "assistant",
+}): AgenticaAssistantMessageHistory {
+  const prompt: IAgenticaHistoryJson.IAssistantMessage = {
+    type: "assistantMessage",
     text: props.text,
   };
   return {
@@ -146,6 +183,9 @@ export function createTextHistory(props: {
   };
 }
 
+/**
+ * @internal
+ */
 export function createDescribeHistory<Model extends ILlmSchema.Model>(props: {
   executes: AgenticaExecuteHistory<Model>[];
   text: string;
@@ -165,6 +205,9 @@ export function createDescribeHistory<Model extends ILlmSchema.Model>(props: {
 /* -----------------------------------------------------------
   FUNCTION CALLING PROMPTS
 ----------------------------------------------------------- */
+/**
+ * @internal
+ */
 export function createSelectHistory<Model extends ILlmSchema.Model>(props: {
   id: string;
   selections: AgenticaOperationSelection<Model>[];
@@ -181,6 +224,9 @@ export function createSelectHistory<Model extends ILlmSchema.Model>(props: {
   };
 }
 
+/**
+ * @internal
+ */
 export function createCancelHistory<Model extends ILlmSchema.Model>(props: {
   id: string;
   selections: AgenticaOperationSelection<Model>[];
@@ -197,6 +243,9 @@ export function createCancelHistory<Model extends ILlmSchema.Model>(props: {
   };
 }
 
+/**
+ * @internal
+ */
 export function createExecuteHistory<
   Model extends ILlmSchema.Model,
 >(props: {

package/src/functional/assertMcpController.ts

@@ -1,4 +1,3 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.d.ts";
 import type { ILlmSchema, IMcpLlmApplication, IMcpTool } from "@samchon/openapi";
 
 import { McpLlm } from "@samchon/openapi";
@@ -23,8 +22,11 @@ import type { IAgenticaController } from "../structures/IAgenticaController";
  */
 export async function assertMcpController<Model extends ILlmSchema.Model>(props: {
   name: string;
-  client: Client;
   model: Model;
+  // @ts-ignore Type checking only when `@modelcontextprotocol/sdk` is installed.
+  //            This strategy is useful for someone who does not need MCP,
+  //            for someone who has not installed `@modelcontextprotocol/sdk`.
+  client: import("@modelcontextprotocol/sdk/client/index.d.ts").Client;
   options?: Partial<IMcpLlmApplication.IOptions<Model>>;
 }): Promise<IAgenticaController.IMcp<Model>> {
   // for peerDependencies

package/src/functional/index.ts

@@ -0,0 +1,7 @@
+export * from "./assertHttpController";
+export * from "./assertHttpLlmApplication"; // deprecated
+export * from "./assertMcpController";
+export * from "./validateHttpController"; // deprecated
+
+export * from "./validateHttpLlmApplication";
+export * from "./validateMcpController";

package/src/functional/validateMcpController.ts

@@ -1,4 +1,3 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.d.ts";
 import type { ILlmSchema, IMcpLlmApplication, IMcpTool, IValidation } from "@samchon/openapi";
 
 import { McpLlm } from "@samchon/openapi";
@@ -25,7 +24,10 @@ export async function validateMcpController<
   Model extends ILlmSchema.Model,
 >(props: {
   name: string;
-  client: Client;
+  // @ts-ignore Type checking only when `@modelcontextprotocol/sdk` is installed.
+  //            This strategy is useful for someone who does not need MCP,
+  //            for someone who has not installed `@modelcontextprotocol/sdk`.
+  client: import("@modelcontextprotocol/sdk/client/index.d.ts").Client;
   model: Model;
   options?: Partial<IMcpLlmApplication.IOptions<Model>>;
 }): Promise<IValidation<IAgenticaController.IMcp<Model>>> {

package/src/histories/{AgenticaTextHistory.ts → AgenticaAssistantMessageHistory.ts}

@@ -2,7 +2,9 @@ import type { IAgenticaHistoryJson } from "../json/IAgenticaHistoryJson";
 
 import type { AgenticaHistoryBase } from "./AgenticaHistoryBase";
 
-export interface AgenticaTextHistory extends AgenticaHistoryBase<"text", IAgenticaHistoryJson.IText> {
-  role: "assistant";
+export interface AgenticaAssistantMessageHistory extends AgenticaHistoryBase<
+  "assistantMessage",
+  IAgenticaHistoryJson.IAssistantMessage
+> {
   text: string;
 }