@agentica/core 0.44.0-dev.20260313-2 → 0.44.0

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,
+};

package/src/context/internal/AgenticaTokenUsageAggregator.ts

@@ -1,66 +1,66 @@
-import type { CompletionUsage } from "openai/resources";
-
-import type { IAgenticaTokenUsageJson } from "../../json/IAgenticaTokenUsageJson";
-import type { AgenticaTokenUsage } from "../AgenticaTokenUsage";
-
-export function aggregate(props: {
-  kind: Exclude<keyof IAgenticaTokenUsageJson, "aggregate">;
-  completionUsage: CompletionUsage;
-  usage: AgenticaTokenUsage;
-}): void {
-  // ----
-  // COMPONENT
-  // ----
-  const component: AgenticaTokenUsage.IComponent = props.usage[props.kind];
-
-  // TOTAL
-  component.total += props.completionUsage.total_tokens;
-
-  // PROMPT
-  component.input.total += props.completionUsage.prompt_tokens;
-  component.input.total
-    += props.completionUsage.prompt_tokens_details?.audio_tokens ?? 0;
-  component.input.cached
-    += props.completionUsage.prompt_tokens_details?.cached_tokens ?? 0;
-
-  // COMPLETION
-  component.output.total += props.completionUsage.completion_tokens;
-  component.output.accepted_prediction
-    += props.completionUsage.completion_tokens_details
-      ?.accepted_prediction_tokens ?? 0;
-  component.output.reasoning
-    += props.completionUsage.completion_tokens_details?.reasoning_tokens ?? 0;
-  component.output.rejected_prediction
-    += props.completionUsage.completion_tokens_details
-      ?.rejected_prediction_tokens ?? 0;
-
-  // ----
-  // RE-AGGREGATE
-  // ----
-  const sum = (getter: (comp: AgenticaTokenUsage.IComponent) => number) =>
-    (
-      Object.entries(props.usage) as [
-        keyof AgenticaTokenUsage,
-        AgenticaTokenUsage.IComponent,
-      ][]
-    )
-      .filter(([key]) => key !== "aggregate")
-      .map(([, comp]) => getter(comp))
-      .reduce((a, b) => a + b, 0);
-  const aggregate: AgenticaTokenUsage.IComponent = props.usage.aggregate;
-  aggregate.total = sum(comp => comp.total);
-  aggregate.input.total = sum(comp => comp.input.total);
-  aggregate.input.cached = sum(comp => comp.input.cached);
-  aggregate.output.total = sum(comp => comp.output.total);
-  aggregate.output.reasoning = sum(comp => comp.output.reasoning);
-  aggregate.output.accepted_prediction = sum(
-    comp => comp.output.accepted_prediction,
-  );
-  aggregate.output.rejected_prediction = sum(
-    comp => comp.output.rejected_prediction,
-  );
-}
-
-export const AgenticaTokenUsageAggregator = {
-  aggregate,
-};
+import type { CompletionUsage } from "openai/resources";
+
+import type { IAgenticaTokenUsageJson } from "../../json/IAgenticaTokenUsageJson";
+import type { AgenticaTokenUsage } from "../AgenticaTokenUsage";
+
+export function aggregate(props: {
+  kind: Exclude<keyof IAgenticaTokenUsageJson, "aggregate">;
+  completionUsage: CompletionUsage;
+  usage: AgenticaTokenUsage;
+}): void {
+  // ----
+  // COMPONENT
+  // ----
+  const component: AgenticaTokenUsage.IComponent = props.usage[props.kind];
+
+  // TOTAL
+  component.total += props.completionUsage.total_tokens;
+
+  // PROMPT
+  component.input.total += props.completionUsage.prompt_tokens;
+  component.input.total
+    += props.completionUsage.prompt_tokens_details?.audio_tokens ?? 0;
+  component.input.cached
+    += props.completionUsage.prompt_tokens_details?.cached_tokens ?? 0;
+
+  // COMPLETION
+  component.output.total += props.completionUsage.completion_tokens;
+  component.output.accepted_prediction
+    += props.completionUsage.completion_tokens_details
+      ?.accepted_prediction_tokens ?? 0;
+  component.output.reasoning
+    += props.completionUsage.completion_tokens_details?.reasoning_tokens ?? 0;
+  component.output.rejected_prediction
+    += props.completionUsage.completion_tokens_details
+      ?.rejected_prediction_tokens ?? 0;
+
+  // ----
+  // RE-AGGREGATE
+  // ----
+  const sum = (getter: (comp: AgenticaTokenUsage.IComponent) => number) =>
+    (
+      Object.entries(props.usage) as [
+        keyof AgenticaTokenUsage,
+        AgenticaTokenUsage.IComponent,
+      ][]
+    )
+      .filter(([key]) => key !== "aggregate")
+      .map(([, comp]) => getter(comp))
+      .reduce((a, b) => a + b, 0);
+  const aggregate: AgenticaTokenUsage.IComponent = props.usage.aggregate;
+  aggregate.total = sum(comp => comp.total);
+  aggregate.input.total = sum(comp => comp.input.total);
+  aggregate.input.cached = sum(comp => comp.input.cached);
+  aggregate.output.total = sum(comp => comp.output.total);
+  aggregate.output.reasoning = sum(comp => comp.output.reasoning);
+  aggregate.output.accepted_prediction = sum(
+    comp => comp.output.accepted_prediction,
+  );
+  aggregate.output.rejected_prediction = sum(
+    comp => comp.output.rejected_prediction,
+  );
+}
+
+export const AgenticaTokenUsageAggregator = {
+  aggregate,
+};

package/src/context/internal/__IChatCancelFunctionsApplication.ts

@@ -1,23 +1,23 @@
-import type { __IChatFunctionReference } from "./__IChatFunctionReference";
-
-export interface __IChatCancelFunctionsApplication {
-  /**
-   * Cancel a function from the candidate list to call.
-   *
-   * If you A.I. agent has understood that the user wants to cancel
-   * some candidate functions to call from the conversation, please cancel
-   * them through this function.
-   *
-   * Also, when you A.I. find a function that has been selected by the candidate
-   * pooling, cancel the function by calling this function. For reference, the
-   * candidate pooling means that user wants only one function to call, but you A.I.
-   * agent selects multiple candidate functions because the A.I. agent can't specify
-   * only one thing due to lack of specificity or homogeneity of candidate functions.
-   *
-   * Additionally, if you A.I. agent wants to cancel same function multiply, you can
-   * do it by assigning the same function name multiply in the `functions` property.
-   *
-   * @param props Properties of the function
-   */
-  cancelFunctions: (props: __IChatFunctionReference.IProps) => Promise<void>;
-}
+import type { __IChatFunctionReference } from "./__IChatFunctionReference";
+
+export interface __IChatCancelFunctionsApplication {
+  /**
+   * Cancel a function from the candidate list to call.
+   *
+   * If you A.I. agent has understood that the user wants to cancel
+   * some candidate functions to call from the conversation, please cancel
+   * them through this function.
+   *
+   * Also, when you A.I. find a function that has been selected by the candidate
+   * pooling, cancel the function by calling this function. For reference, the
+   * candidate pooling means that user wants only one function to call, but you A.I.
+   * agent selects multiple candidate functions because the A.I. agent can't specify
+   * only one thing due to lack of specificity or homogeneity of candidate functions.
+   *
+   * Additionally, if you A.I. agent wants to cancel same function multiply, you can
+   * do it by assigning the same function name multiply in the `functions` property.
+   *
+   * @param props Properties of the function
+   */
+  cancelFunctions: (props: __IChatFunctionReference.IProps) => Promise<void>;
+}

package/src/context/internal/__IChatFunctionReference.ts

@@ -1,21 +1,21 @@
-export interface __IChatFunctionReference {
-  /**
-   * The reason of the function selection.
-   *
-   * Just write the reason why you've determined to select this function.
-   */
-  reason: string;
-
-  /**
-   * Name of the target function to call.
-   */
-  name: string;
-}
-export namespace __IChatFunctionReference {
-  export interface IProps {
-    /**
-     * List of target functions.
-     */
-    functions: __IChatFunctionReference[];
-  }
-}
+export interface __IChatFunctionReference {
+  /**
+   * The reason of the function selection.
+   *
+   * Just write the reason why you've determined to select this function.
+   */
+  reason: string;
+
+  /**
+   * Name of the target function to call.
+   */
+  name: string;
+}
+export namespace __IChatFunctionReference {
+  export interface IProps {
+    /**
+     * List of target functions.
+     */
+    functions: __IChatFunctionReference[];
+  }
+}

package/src/context/internal/__IChatInitialApplication.ts

@@ -1,15 +1,13 @@
-import type { IHttpLlmFunction } from "@typia/interface";
-
-export interface __IChatInitialApplication {
-  /**
-   * Get list of API functions.
-   *
-   * If user seems like to request some function calling except this one,
-   * call this `getApiFunctions()` to get the list of candidate API functions
-   * provided from this application.
-   *
-   * Also, user just wants to list up every remote API functions that can be
-   * called from the backend server, utilize this function too.
-   */
-  getApiFunctions: (props: object) => Promise<Array<IHttpLlmFunction>>;
-}
+export interface __IChatInitialApplication {
+  /**
+   * Get list of API functions.
+   *
+   * If user seems like to request some function calling except this one,
+   * call this `getApiFunctions()` to get the list of candidate API functions
+   * provided from this application.
+   *
+   * Also, user just wants to list up every remote API functions that can be
+   * called from the backend server, utilize this function too.
+   */
+  getApiFunctions: (props: object) => Promise<void>;
+}

package/src/context/internal/__IChatSelectFunctionsApplication.ts

@@ -1,24 +1,24 @@
-import type { __IChatFunctionReference } from "./__IChatFunctionReference";
-
-export interface __IChatSelectFunctionsApplication {
-  /**
-   * Select proper API functions to call.
-   *
-   * If you A.I. agent has found some proper API functions to call
-   * from the conversation with user, please select the API functions
-   * just by calling this function.
-   *
-   * When user wants to call a same function multiply, you A.I. agent must
-   * list up it multiply in the `functions` property. Otherwise the user has
-   * requested to call many different functions, you A.I. agent have to assign
-   * them all into the `functions` property.
-   *
-   * Also, if you A.I. agent can't specify a specific function to call due to lack
-   * of specificity or homogeneity of candidate functions, just assign all of them
-   * by in the` functions` property` too. Instead, when you A.I. agent can specify
-   * a specific function to call, the others would be eliminated.
-   *
-   * @param props Properties of the function
-   */
-  selectFunctions: (props: __IChatFunctionReference.IProps) => Promise<void>;
-}
+import type { __IChatFunctionReference } from "./__IChatFunctionReference";
+
+export interface __IChatSelectFunctionsApplication {
+  /**
+   * Select proper API functions to call.
+   *
+   * If you A.I. agent has found some proper API functions to call
+   * from the conversation with user, please select the API functions
+   * just by calling this function.
+   *
+   * When user wants to call a same function multiply, you A.I. agent must
+   * list up it multiply in the `functions` property. Otherwise the user has
+   * requested to call many different functions, you A.I. agent have to assign
+   * them all into the `functions` property.
+   *
+   * Also, if you A.I. agent can't specify a specific function to call due to lack
+   * of specificity or homogeneity of candidate functions, just assign all of them
+   * by in the` functions` property` too. Instead, when you A.I. agent can specify
+   * a specific function to call, the others would be eliminated.
+   *
+   * @param props Properties of the function
+   */
+  selectFunctions: (props: __IChatFunctionReference.IProps) => Promise<void>;
+}