@agentica/core 0.12.1 → 0.12.2-dev.20250314

package/src/context/AgenticaTokenUsage.ts

@@ -1,170 +1,170 @@
-import typia from "typia";
-
-import { IAgenticaTokenUsageJson } from "../json/IAgenticaTokenUsageJson";
-
-export class AgenticaTokenUsage implements IAgenticaTokenUsageJson {
-  /**
-   * Aggregated token usage.
-   */
-  public readonly aggregate: IAgenticaTokenUsageJson.IComponent;
-
-  /**
-   * Token uasge of initializer agent.
-   */
-  public readonly initialize: IAgenticaTokenUsageJson.IComponent;
-
-  /**
-   * Token usage of function selector agent.
-   */
-  public readonly select: IAgenticaTokenUsageJson.IComponent;
-
-  /**
-   * Token usage of function canceler agent.
-   */
-  public readonly cancel: IAgenticaTokenUsageJson.IComponent;
-
-  /**
-   * Token usage of function caller agent.
-   */
-  public readonly call: IAgenticaTokenUsageJson.IComponent;
-
-  /**
-   * Token usage of function calling describer agent.
-   */
-  public readonly describe: IAgenticaTokenUsageJson.IComponent;
-
-  public constructor(props?: IAgenticaTokenUsageJson) {
-    if (props === undefined) {
-      const zero = AgenticaTokenUsage.zero();
-      this.aggregate = zero.aggregate;
-      this.initialize = zero.initialize;
-      this.select = zero.select;
-      this.cancel = zero.cancel;
-      this.call = zero.call;
-      this.describe = zero.describe;
-    } else {
-      this.aggregate = props.aggregate;
-      this.initialize = props.initialize;
-      this.select = props.select;
-      this.cancel = props.cancel;
-      this.call = props.call;
-      this.describe = props.describe;
-    }
-  }
-
-  public increment(y: IAgenticaTokenUsageJson): void {
-    const increment = (
-      x: IAgenticaTokenUsageJson.IComponent,
-      y: IAgenticaTokenUsageJson.IComponent,
-    ): void => {
-      x.total += y.total;
-      x.input.total += y.input.total;
-      x.input.cached += y.input.cached;
-      x.output.total += y.output.total;
-      x.output.reasoning += y.output.reasoning;
-      x.output.accepted_prediction += y.output.accepted_prediction;
-      x.output.rejected_prediction += y.output.rejected_prediction;
-    };
-    increment(this.aggregate, y.aggregate);
-    increment(this.initialize, y.initialize);
-    increment(this.select, y.select);
-    increment(this.cancel, y.cancel);
-    increment(this.call, y.call);
-    increment(this.describe, y.describe);
-  }
-
-  public toJSON(): IAgenticaTokenUsageJson {
-    return typia.misc.clone<IAgenticaTokenUsageJson>(this);
-  }
-
-  public static zero(): AgenticaTokenUsage {
-    const component = (): IAgenticaTokenUsageJson.IComponent => ({
-      total: 0,
-      input: {
-        total: 0,
-        cached: 0,
-      },
-      output: {
-        total: 0,
-        reasoning: 0,
-        accepted_prediction: 0,
-        rejected_prediction: 0,
-      },
-    });
-    return new AgenticaTokenUsage({
-      aggregate: component(),
-      initialize: component(),
-      select: component(),
-      cancel: component(),
-      call: component(),
-      describe: component(),
-    });
-  }
-
-  public static plus(
-    x: AgenticaTokenUsage,
-    y: AgenticaTokenUsage,
-  ): AgenticaTokenUsage {
-    const z: AgenticaTokenUsage = new AgenticaTokenUsage(x);
-    z.increment(y.toJSON());
-    return z;
-  }
-}
-export namespace AgenticaTokenUsage {
-  export interface IComponent {
-    /**
-     * Total token usage.
-     */
-    total: number;
-
-    /**
-     * Input token usage of detailed.
-     */
-    input: IInput;
-
-    /**
-     * Output token usage of detailed.
-     */
-    output: IOutput;
-  }
-
-  /**
-   * Input token usage of detailed.
-   */
-  export interface IInput {
-    /**
-     * Total amount of input token uasge.
-     */
-    total: number;
-
-    /**
-     * Cached token usage.
-     */
-    cached: number;
-  }
-
-  /**
-   * Output token usage of detailed.
-   */
-  export interface IOutput {
-    /**
-     * Total amount of output token usage.
-     */
-    total: number;
-
-    /**
-     * Reasoning token usage.
-     */
-    reasoning: number;
-
-    /**
-     * Prediction token usage.
-     */
-    accepted_prediction: number;
-
-    /**
-     * Rejected prediction token usage.
-     */
-    rejected_prediction: number;
-  }
-}
+import typia from "typia";
+
+import { IAgenticaTokenUsageJson } from "../json/IAgenticaTokenUsageJson";
+
+export class AgenticaTokenUsage implements IAgenticaTokenUsageJson {
+  /**
+   * Aggregated token usage.
+   */
+  public readonly aggregate: IAgenticaTokenUsageJson.IComponent;
+
+  /**
+   * Token uasge of initializer agent.
+   */
+  public readonly initialize: IAgenticaTokenUsageJson.IComponent;
+
+  /**
+   * Token usage of function selector agent.
+   */
+  public readonly select: IAgenticaTokenUsageJson.IComponent;
+
+  /**
+   * Token usage of function canceler agent.
+   */
+  public readonly cancel: IAgenticaTokenUsageJson.IComponent;
+
+  /**
+   * Token usage of function caller agent.
+   */
+  public readonly call: IAgenticaTokenUsageJson.IComponent;
+
+  /**
+   * Token usage of function calling describer agent.
+   */
+  public readonly describe: IAgenticaTokenUsageJson.IComponent;
+
+  public constructor(props?: IAgenticaTokenUsageJson) {
+    if (props === undefined) {
+      const zero = AgenticaTokenUsage.zero();
+      this.aggregate = zero.aggregate;
+      this.initialize = zero.initialize;
+      this.select = zero.select;
+      this.cancel = zero.cancel;
+      this.call = zero.call;
+      this.describe = zero.describe;
+    } else {
+      this.aggregate = props.aggregate;
+      this.initialize = props.initialize;
+      this.select = props.select;
+      this.cancel = props.cancel;
+      this.call = props.call;
+      this.describe = props.describe;
+    }
+  }
+
+  public increment(y: IAgenticaTokenUsageJson): void {
+    const increment = (
+      x: IAgenticaTokenUsageJson.IComponent,
+      y: IAgenticaTokenUsageJson.IComponent,
+    ): void => {
+      x.total += y.total;
+      x.input.total += y.input.total;
+      x.input.cached += y.input.cached;
+      x.output.total += y.output.total;
+      x.output.reasoning += y.output.reasoning;
+      x.output.accepted_prediction += y.output.accepted_prediction;
+      x.output.rejected_prediction += y.output.rejected_prediction;
+    };
+    increment(this.aggregate, y.aggregate);
+    increment(this.initialize, y.initialize);
+    increment(this.select, y.select);
+    increment(this.cancel, y.cancel);
+    increment(this.call, y.call);
+    increment(this.describe, y.describe);
+  }
+
+  public toJSON(): IAgenticaTokenUsageJson {
+    return typia.misc.clone<IAgenticaTokenUsageJson>(this);
+  }
+
+  public static zero(): AgenticaTokenUsage {
+    const component = (): IAgenticaTokenUsageJson.IComponent => ({
+      total: 0,
+      input: {
+        total: 0,
+        cached: 0,
+      },
+      output: {
+        total: 0,
+        reasoning: 0,
+        accepted_prediction: 0,
+        rejected_prediction: 0,
+      },
+    });
+    return new AgenticaTokenUsage({
+      aggregate: component(),
+      initialize: component(),
+      select: component(),
+      cancel: component(),
+      call: component(),
+      describe: component(),
+    });
+  }
+
+  public static plus(
+    x: AgenticaTokenUsage,
+    y: AgenticaTokenUsage,
+  ): AgenticaTokenUsage {
+    const z: AgenticaTokenUsage = new AgenticaTokenUsage(x);
+    z.increment(y.toJSON());
+    return z;
+  }
+}
+export namespace AgenticaTokenUsage {
+  export interface IComponent {
+    /**
+     * Total token usage.
+     */
+    total: number;
+
+    /**
+     * Input token usage of detailed.
+     */
+    input: IInput;
+
+    /**
+     * Output token usage of detailed.
+     */
+    output: IOutput;
+  }
+
+  /**
+   * Input token usage of detailed.
+   */
+  export interface IInput {
+    /**
+     * Total amount of input token uasge.
+     */
+    total: number;
+
+    /**
+     * Cached token usage.
+     */
+    cached: number;
+  }
+
+  /**
+   * Output token usage of detailed.
+   */
+  export interface IOutput {
+    /**
+     * Total amount of output token usage.
+     */
+    total: number;
+
+    /**
+     * Reasoning token usage.
+     */
+    reasoning: number;
+
+    /**
+     * Prediction token usage.
+     */
+    accepted_prediction: number;
+
+    /**
+     * Rejected prediction token usage.
+     */
+    rejected_prediction: number;
+  }
+}

package/src/context/internal/AgenticaTokenUsageAggregator.ts

@@ -1,66 +1,66 @@
-import { CompletionUsage } from "openai/resources";
-
-import { IAgenticaTokenUsageJson } from "../../json/IAgenticaTokenUsageJson";
-import { AgenticaTokenUsage } from "../AgenticaTokenUsage";
-
-export namespace AgenticaTokenUsageAggregator {
-  export const aggregate = (props: {
-    kind: Exclude<keyof IAgenticaTokenUsageJson, "aggregate">;
-    completionUsage: CompletionUsage;
-    usage: AgenticaTokenUsage;
-  }): void => {
-    if (!props.completionUsage) return;
-
-    //----
-    // 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,
-    );
-  };
-}
+import { CompletionUsage } from "openai/resources";
+
+import { IAgenticaTokenUsageJson } from "../../json/IAgenticaTokenUsageJson";
+import { AgenticaTokenUsage } from "../AgenticaTokenUsage";
+
+export namespace AgenticaTokenUsageAggregator {
+  export const aggregate = (props: {
+    kind: Exclude<keyof IAgenticaTokenUsageJson, "aggregate">;
+    completionUsage: CompletionUsage;
+    usage: AgenticaTokenUsage;
+  }): void => {
+    if (!props.completionUsage) return;
+
+    //----
+    // 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,
+    );
+  };
+}

package/src/context/internal/__IChatCancelFunctionsApplication.ts

@@ -1,23 +1,23 @@
-import { __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 { __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,15 @@
-import { IHttpLlmFunction } from "@samchon/openapi";
-
-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({}): Promise<Array<IHttpLlmFunction<"chatgpt">>>;
-}
+import { IHttpLlmFunction } from "@samchon/openapi";
+
+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({}): Promise<Array<IHttpLlmFunction<"chatgpt">>>;
+}

package/src/context/internal/__IChatSelectFunctionsApplication.ts

@@ -1,24 +1,24 @@
-import { __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 { __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>;
+}