@agentica/core 0.43.3 → 0.44.0-dev.20260313

package/src/context/MicroAgenticaContext.ts

@@ -1,99 +1,99 @@
-import type OpenAI from "openai";
-
-import type { MicroAgenticaEvent } from "../events/MicroAgenticaEvent";
-import type { AgenticaUserMessageHistory } from "../histories/AgenticaUserMessageHistory";
-import type { MicroAgenticaHistory } from "../histories/MicroAgenticaHistory";
-import type { IMicroAgenticaConfig } from "../structures/IMicroAgenticaConfig";
-
-import type { AgenticaContextRequestResult } from "./AgenticaContextRequestResult";
-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 {
-  // ----
-  // 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;
-
-  /**
-   * 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 | undefined;
-
-  // ----
-  // STATES
-  // ----
-  /**
-   * Prompt histories.
-   */
-  histories: MicroAgenticaHistory[];
-
-  /**
-   * Text prompt of the user.
-   *
-   * Text conversation written the by user through the
-   * {@link Agentica.conversate} function.
-   */
-  prompt: AgenticaUserMessageHistory;
-
-  /**
-   * Abort signal.
-   */
-  abortSignal?: AbortSignal;
-  // ----
-  // HANDLERS
-  // ----
-  /**
-   * Dispatch event.
-   *
-   * Dispatch event so that the agent can be handle the event
-   * through the {@link MicroAgentica.on} function.
-   *
-   * @param event Event to deliver
-   */
-  dispatch: (event: MicroAgenticaEvent) => 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<AgenticaContextRequestResult>;
-}
+import type OpenAI from "openai";
+
+import type { MicroAgenticaEvent } from "../events/MicroAgenticaEvent";
+import type { AgenticaUserMessageHistory } from "../histories/AgenticaUserMessageHistory";
+import type { MicroAgenticaHistory } from "../histories/MicroAgenticaHistory";
+import type { IMicroAgenticaConfig } from "../structures/IMicroAgenticaConfig";
+
+import type { AgenticaContextRequestResult } from "./AgenticaContextRequestResult";
+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 {
+  // ----
+  // 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;
+
+  /**
+   * 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 | undefined;
+
+  // ----
+  // STATES
+  // ----
+  /**
+   * Prompt histories.
+   */
+  histories: MicroAgenticaHistory[];
+
+  /**
+   * Text prompt of the user.
+   *
+   * Text conversation written the by user through the
+   * {@link Agentica.conversate} function.
+   */
+  prompt: AgenticaUserMessageHistory;
+
+  /**
+   * Abort signal.
+   */
+  abortSignal?: AbortSignal;
+  // ----
+  // HANDLERS
+  // ----
+  /**
+   * Dispatch event.
+   *
+   * Dispatch event so that the agent can be handle the event
+   * through the {@link MicroAgentica.on} function.
+   *
+   * @param event Event to deliver
+   */
+  dispatch: (event: MicroAgenticaEvent) => 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<AgenticaContextRequestResult>;
+}

package/src/context/index.ts

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

package/src/context/internal/AgenticaOperationComposer.ts

@@ -1,177 +1,177 @@
-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";
-
-import { __map_take } from "../../utils/__map_take";
-
-/**
- * Compose the agentica operation collection.
- *
- * Compose the {@link AgenticaOperationCollection} from the given
- * controllers and config.
- *
- * @internal
- */
-export function compose(props: {
-  controllers: IAgenticaController[];
-  config?: IAgenticaConfig | IMicroAgenticaConfig | undefined;
-}): AgenticaOperationCollection {
-  const unique: boolean = (props.controllers.length === 1 || (() => {
-    const names = props.controllers.map(
-
-      controllers => controllers.application.functions.map((func: { name: string }) => func.name),
-    ).flat();
-    return new Set(names).size === names.length;
-  })());
-
-  const array: AgenticaOperation[] = getOperations({
-    controllers: props.controllers,
-    naming: (func: string, controllerIndex: number) => unique ? func : `_${controllerIndex}_${func}`,
-  });
-  const capacity: number | undefined = (props.config as IAgenticaConfig)?.capacity;
-  const divided: AgenticaOperation[][] | undefined
-      = capacity !== undefined && array.length > capacity
-        ? divide({
-            array,
-            capacity,
-          })
-        : undefined;
-
-  const flat: Map<string, AgenticaOperation> = new Map();
-  const group: Map<string, Map<string, AgenticaOperation>> = new Map();
-  for (const item of array) {
-    flat.set(item.name, item);
-    __map_take(group, item.controller.name, () => new Map()).set(
-      item.name,
-      item,
-    );
-  }
-  return {
-    array,
-    divided,
-    flat,
-    group,
-  };
-}
-
-/**
- * @internal
- */
-export function getOperations(props: {
-  controllers: IAgenticaController[];
-  naming: (func: string, controllerIndex: number) => string;
-}): AgenticaOperation[] {
-  return props.controllers.flatMap((controller, idx) => {
-    switch (controller.protocol) {
-      case "http":{
-        return toHttpOperations({ controller, index: idx, naming: props.naming }); }
-      case "class":{
-        return toClassOperations({ controller, index: idx, naming: props.naming }); }
-      case "mcp": {
-        return toMcpOperations({ controller, index: idx, naming: props.naming });
-      }
-      default:
-        controller satisfies never;
-        throw new Error(`Unsupported protocol: ${(controller as { protocol: string }).protocol}`);
-    }
-  });
-}
-
-/**
- * @internal
- */
-export function toHttpOperations(props: {
-  controller: IAgenticaController.IHttp;
-  index: number;
-  naming: (func: string, controllerIndex: number) => string;
-}): AgenticaOperation[] {
-  return props.controller.application.functions.map(func => ({
-    protocol: "http",
-    controller: props.controller,
-    function: func,
-    name: props.naming(func.name, props.index),
-    toJSON: () => ({
-      protocol: "http",
-      controller: props.controller.name,
-      function: func.name,
-      name: props.naming(func.name, props.index),
-    }),
-  }));
-}
-
-/**
- * @internal
- */
-export function toClassOperations(props: {
-  controller: IAgenticaController.IClass;
-  index: number;
-  naming: (func: string, controllerIndex: number) => string;
-}): AgenticaOperation[] {
-  return props.controller.application.functions.map(func => ({
-    protocol: "class",
-    controller: props.controller,
-    function: func,
-    name: props.naming(func.name, props.index),
-    toJSON: () => ({
-      protocol: "class",
-      controller: props.controller.name,
-      function: func.name,
-      name: props.naming(func.name, props.index),
-    }),
-  }));
-}
-
-/**
- * @internal
- */
-export function toMcpOperations(props: {
-  controller: IAgenticaController.IMcp;
-  index: number;
-  naming: (func: string, controllerIndex: number) => string;
-}): AgenticaOperation[] {
-  return props.controller.application.functions.map(func => ({
-    protocol: "mcp",
-    controller: props.controller,
-
-    function: func,
-
-    name: props.naming(func.name, props.index),
-    toJSON: () => ({
-      protocol: "mcp",
-      controller: props.controller.name,
-
-      function: func.name,
-
-      name: props.naming(func.name, props.index),
-    }),
-  }));
-}
-
-/**
- * @internal
- */
-export function divide<T>(props: {
-  array: T[];
-  capacity: number;
-}): T[][] {
-  if (props.capacity <= 0) {
-    throw new Error("Capacity must be a positive integer");
-  }
-  if (Number.isNaN(props.capacity)) {
-    throw new TypeError("Capacity must be a positive integer");
-  }
-  if (props.capacity === Infinity) {
-    throw new Error("Capacity must be a positive integer");
-  }
-
-  const size: number = Math.ceil(props.array.length / props.capacity);
-  const capacity: number = Math.ceil(props.array.length / size);
-  const replica: T[] = props.array.slice();
-  return Array.from({ length: size }, () => replica.splice(0, capacity));
-}
-
-export const AgenticaOperationComposer = {
-  compose,
-};
+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";
+
+import { __map_take } from "../../utils/__map_take";
+
+/**
+ * Compose the agentica operation collection.
+ *
+ * Compose the {@link AgenticaOperationCollection} from the given
+ * controllers and config.
+ *
+ * @internal
+ */
+export function compose(props: {
+  controllers: IAgenticaController[];
+  config?: IAgenticaConfig | IMicroAgenticaConfig | undefined;
+}): AgenticaOperationCollection {
+  const unique: boolean = (props.controllers.length === 1 || (() => {
+    const names = props.controllers.map(
+
+      controllers => controllers.application.functions.map((func: { name: string }) => func.name),
+    ).flat();
+    return new Set(names).size === names.length;
+  })());
+
+  const array: AgenticaOperation[] = getOperations({
+    controllers: props.controllers,
+    naming: (func: string, controllerIndex: number) => unique ? func : `_${controllerIndex}_${func}`,
+  });
+  const capacity: number | undefined = (props.config as IAgenticaConfig)?.capacity;
+  const divided: AgenticaOperation[][] | undefined
+    = capacity !== undefined && array.length > capacity
+      ? divide({
+          array,
+          capacity,
+        })
+      : undefined;
+
+  const flat: Map<string, AgenticaOperation> = new Map();
+  const group: Map<string, Map<string, AgenticaOperation>> = new Map();
+  for (const item of array) {
+    flat.set(item.name, item);
+    __map_take(group, item.controller.name, () => new Map()).set(
+      item.name,
+      item,
+    );
+  }
+  return {
+    array,
+    divided,
+    flat,
+    group,
+  };
+}
+
+/**
+ * @internal
+ */
+export function getOperations(props: {
+  controllers: IAgenticaController[];
+  naming: (func: string, controllerIndex: number) => string;
+}): AgenticaOperation[] {
+  return props.controllers.flatMap((controller, idx) => {
+    switch (controller.protocol) {
+      case "http":{
+        return toHttpOperations({ controller, index: idx, naming: props.naming }); }
+      case "class":{
+        return toClassOperations({ controller, index: idx, naming: props.naming }); }
+      case "mcp": {
+        return toMcpOperations({ controller, index: idx, naming: props.naming });
+      }
+      default:
+        controller satisfies never;
+        throw new Error(`Unsupported protocol: ${(controller as { protocol: string }).protocol}`);
+    }
+  });
+}
+
+/**
+ * @internal
+ */
+export function toHttpOperations(props: {
+  controller: IAgenticaController.IHttp;
+  index: number;
+  naming: (func: string, controllerIndex: number) => string;
+}): AgenticaOperation[] {
+  return props.controller.application.functions.map(func => ({
+    protocol: "http",
+    controller: props.controller,
+    function: func,
+    name: props.naming(func.name, props.index),
+    toJSON: () => ({
+      protocol: "http",
+      controller: props.controller.name,
+      function: func.name,
+      name: props.naming(func.name, props.index),
+    }),
+  }));
+}
+
+/**
+ * @internal
+ */
+export function toClassOperations(props: {
+  controller: IAgenticaController.IClass;
+  index: number;
+  naming: (func: string, controllerIndex: number) => string;
+}): AgenticaOperation[] {
+  return props.controller.application.functions.map(func => ({
+    protocol: "class",
+    controller: props.controller,
+    function: func,
+    name: props.naming(func.name, props.index),
+    toJSON: () => ({
+      protocol: "class",
+      controller: props.controller.name,
+      function: func.name,
+      name: props.naming(func.name, props.index),
+    }),
+  }));
+}
+
+/**
+ * @internal
+ */
+export function toMcpOperations(props: {
+  controller: IAgenticaController.IMcp;
+  index: number;
+  naming: (func: string, controllerIndex: number) => string;
+}): AgenticaOperation[] {
+  return props.controller.application.functions.map(func => ({
+    protocol: "mcp",
+    controller: props.controller,
+
+    function: func,
+
+    name: props.naming(func.name, props.index),
+    toJSON: () => ({
+      protocol: "mcp",
+      controller: props.controller.name,
+
+      function: func.name,
+
+      name: props.naming(func.name, props.index),
+    }),
+  }));
+}
+
+/**
+ * @internal
+ */
+export function divide<T>(props: {
+  array: T[];
+  capacity: number;
+}): T[][] {
+  if (props.capacity <= 0) {
+    throw new Error("Capacity must be a positive integer");
+  }
+  if (Number.isNaN(props.capacity)) {
+    throw new TypeError("Capacity must be a positive integer");
+  }
+  if (props.capacity === Infinity) {
+    throw new Error("Capacity must be a positive integer");
+  }
+
+  const size: number = Math.ceil(props.array.length / props.capacity);
+  const capacity: number = Math.ceil(props.array.length / size);
+  const replica: T[] = props.array.slice();
+  return Array.from({ length: size }, () => replica.splice(0, capacity));
+}
+
+export const AgenticaOperationComposer = {
+  compose,
+};