@agentica/core 0.8.3 → 0.9.0-dev.20250302

package/src/internal/AgenticaPromptTransformer.ts

@@ -1,83 +1,86 @@
-import { Primitive } from "typia";
-
-import { IAgenticaOperation } from "../structures/IAgenticaOperation";
-import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
-import { AgenticaPromptFactory } from "./AgenticaPromptFactory";
-
-export namespace AgenticaPromptTransformer {
-  export const transform = (props: {
-    operations: Map<string, Map<string, IAgenticaOperation>>;
-    input: Primitive<IAgenticaPrompt>;
-  }): IAgenticaPrompt => {
-    // TEXT
-    if (props.input.type === "text") return props.input;
-    // SELECT & CANCEL
-    else if (props.input.type === "select" || props.input.type === "cancel")
-      return {
-        ...props.input,
-        operations: props.input.operations.map((func) =>
-          AgenticaPromptFactory.selection({
-            ...findOperation({
-              operations: props.operations,
-              input: func,
-            }),
-            reason: func.reason,
-          }),
-        ),
-      } satisfies IAgenticaPrompt.ISelect | IAgenticaPrompt.ICancel;
-    // EXECUTE
-    else if (props.input.type === "execute")
-      return transformExecute({
-        operations: props.operations,
-        input: props.input,
-      }) satisfies IAgenticaPrompt.IExecute;
-    // DESCRIBE
-    return {
-      type: "describe",
-      text: props.input.text,
-      executions: props.input.executions.map((next) =>
-        transformExecute({
-          operations: props.operations,
-          input: next,
-        }),
-      ),
-    } satisfies IAgenticaPrompt.IDescribe;
-  };
-
-  const transformExecute = (props: {
-    operations: Map<string, Map<string, IAgenticaOperation>>;
-    input: Primitive<IAgenticaPrompt.IExecute>;
-  }): IAgenticaPrompt.IExecute => {
-    const operation = findOperation({
-      operations: props.operations,
-      input: props.input,
-    });
-    return AgenticaPromptFactory.execute({
-      type: "execute",
-      protocol: operation.protocol as "http",
-      controller: operation.controller,
-      function: operation.function,
-      id: props.input.id,
-      name: props.input.name,
-      arguments: props.input.arguments,
-      value: props.input.value,
-    });
-  };
-
-  const findOperation = (props: {
-    operations: Map<string, Map<string, IAgenticaOperation>>;
-    input: {
-      controller: string;
-      function: string;
-    };
-  }): IAgenticaOperation.IHttp => {
-    const found: IAgenticaOperation | undefined = props.operations
-      .get(props.input.controller)
-      ?.get(props.input.function);
-    if (found === undefined)
-      throw new Error(
-        `No operation found: (controller: ${props.input.controller}, function: ${props.input.function})`,
-      );
-    return found as IAgenticaOperation.IHttp;
-  };
-}
+import { ILlmSchema } from "@samchon/openapi";
+import { Primitive } from "typia";
+
+import { IAgenticaOperation } from "../structures/IAgenticaOperation";
+import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
+import { AgenticaPromptFactory } from "./AgenticaPromptFactory";
+
+export namespace AgenticaPromptTransformer {
+  export const transform = <Model extends ILlmSchema.Model>(props: {
+    operations: Map<string, Map<string, IAgenticaOperation<Model>>>;
+    input: Primitive<IAgenticaPrompt<Model>>;
+  }): IAgenticaPrompt<Model> => {
+    // TEXT
+    if (props.input.type === "text") return props.input;
+    // SELECT & CANCEL
+    else if (props.input.type === "select" || props.input.type === "cancel")
+      return {
+        ...props.input,
+        operations: props.input.operations.map((func) =>
+          AgenticaPromptFactory.selection({
+            ...findOperation({
+              operations: props.operations,
+              input: func,
+            }),
+            reason: func.reason,
+          }),
+        ),
+      } satisfies
+        | IAgenticaPrompt.ISelect<Model>
+        | IAgenticaPrompt.ICancel<Model>;
+    // EXECUTE
+    else if (props.input.type === "execute")
+      return transformExecute({
+        operations: props.operations,
+        input: props.input,
+      }) satisfies IAgenticaPrompt.IExecute<Model>;
+    // DESCRIBE
+    return {
+      type: "describe",
+      text: props.input.text,
+      executions: props.input.executions.map((next) =>
+        transformExecute({
+          operations: props.operations,
+          input: next,
+        }),
+      ),
+    } satisfies IAgenticaPrompt.IDescribe<Model>;
+  };
+
+  const transformExecute = <Model extends ILlmSchema.Model>(props: {
+    operations: Map<string, Map<string, IAgenticaOperation<Model>>>;
+    input: Primitive<IAgenticaPrompt.IExecute<Model>>;
+  }): IAgenticaPrompt.IExecute<Model> => {
+    const operation = findOperation({
+      operations: props.operations,
+      input: props.input,
+    });
+    return AgenticaPromptFactory.execute({
+      type: "execute",
+      protocol: operation.protocol as "http",
+      controller: operation.controller,
+      function: operation.function,
+      id: props.input.id,
+      name: props.input.name,
+      arguments: props.input.arguments,
+      value: props.input.value,
+    });
+  };
+
+  const findOperation = <Model extends ILlmSchema.Model>(props: {
+    operations: Map<string, Map<string, IAgenticaOperation<Model>>>;
+    input: {
+      controller: string;
+      function: string;
+    };
+  }): IAgenticaOperation.IHttp<Model> => {
+    const found: IAgenticaOperation<Model> | undefined = props.operations
+      .get(props.input.controller)
+      ?.get(props.input.function);
+    if (found === undefined)
+      throw new Error(
+        `No operation found: (controller: ${props.input.controller}, function: ${props.input.function})`,
+      );
+    return found as IAgenticaOperation.IHttp<Model>;
+  };
+}

package/src/internal/AgenticaTokenUsageAggregator.ts

@@ -1,115 +1,115 @@
-import OpenAI from "openai";
-
-import { IAgenticaTokenUsage } from "../structures/IAgenticaTokenUsage";
-
-export namespace AgenticaTokenUsageAggregator {
-  export const aggregate = (props: {
-    kind: Exclude<keyof IAgenticaTokenUsage, "aggregate">;
-    completion: OpenAI.ChatCompletion;
-    usage: IAgenticaTokenUsage;
-  }): void => {
-    if (!props.completion.usage) return;
-
-    //----
-    // COMPONENT
-    //----
-    const component: IAgenticaTokenUsage.IComponent = props.usage[props.kind];
-
-    // TOTAL
-    component.total += props.completion.usage.total_tokens;
-
-    // PROMPT
-    component.input.total += props.completion.usage.prompt_tokens;
-    props.completion.usage.prompt_tokens_details?.audio_tokens ?? 0;
-    component.input.cached +=
-      props.completion.usage.prompt_tokens_details?.cached_tokens ?? 0;
-
-    // COMPLETION
-    component.output.total += props.completion.usage.total_tokens;
-    component.output.accepted_prediction +=
-      props.completion.usage.completion_tokens_details
-        ?.accepted_prediction_tokens ?? 0;
-    component.output.reasoning +=
-      props.completion.usage.completion_tokens_details?.reasoning_tokens ?? 0;
-    component.output.rejected_prediction +=
-      props.completion.usage.completion_tokens_details
-        ?.rejected_prediction_tokens ?? 0;
-
-    //----
-    // RE-AGGREGATE
-    //----
-    const sum = (getter: (comp: IAgenticaTokenUsage.IComponent) => number) =>
-      Object.entries(props.usage)
-        .filter(([key]) => key !== "aggregate")
-        .map(([_, comp]) => getter(comp))
-        .reduce((a, b) => a + b, 0);
-    const aggregate: IAgenticaTokenUsage.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 plus = (
-    x: IAgenticaTokenUsage,
-    y: IAgenticaTokenUsage,
-  ): IAgenticaTokenUsage => {
-    const component = (
-      a: IAgenticaTokenUsage.IComponent,
-      b: IAgenticaTokenUsage.IComponent,
-    ): IAgenticaTokenUsage.IComponent => ({
-      total: a.total + b.total,
-      input: {
-        total: a.input.total + b.input.total,
-        cached: a.input.cached + b.input.cached,
-      },
-      output: {
-        total: a.output.total + b.output.total,
-        reasoning: a.output.reasoning + b.output.reasoning,
-        accepted_prediction:
-          a.output.accepted_prediction + b.output.accepted_prediction,
-        rejected_prediction:
-          a.output.rejected_prediction + b.output.rejected_prediction,
-      },
-    });
-    return {
-      aggregate: component(x.aggregate, y.aggregate),
-      initialize: component(x.initialize, y.initialize),
-      select: component(x.select, y.select),
-      cancel: component(x.cancel, y.cancel),
-      call: component(x.call, y.call),
-      describe: component(x.describe, y.describe),
-    };
-  };
-
-  export const zero = (): IAgenticaTokenUsage => {
-    const component = (): IAgenticaTokenUsage.IComponent => ({
-      total: 0,
-      input: {
-        total: 0,
-        cached: 0,
-      },
-      output: {
-        total: 0,
-        reasoning: 0,
-        accepted_prediction: 0,
-        rejected_prediction: 0,
-      },
-    });
-    return {
-      aggregate: component(),
-      initialize: component(),
-      select: component(),
-      cancel: component(),
-      call: component(),
-      describe: component(),
-    };
-  };
-}
+import OpenAI from "openai";
+
+import { IAgenticaTokenUsage } from "../structures/IAgenticaTokenUsage";
+
+export namespace AgenticaTokenUsageAggregator {
+  export const aggregate = (props: {
+    kind: Exclude<keyof IAgenticaTokenUsage, "aggregate">;
+    completion: OpenAI.ChatCompletion;
+    usage: IAgenticaTokenUsage;
+  }): void => {
+    if (!props.completion.usage) return;
+
+    //----
+    // COMPONENT
+    //----
+    const component: IAgenticaTokenUsage.IComponent = props.usage[props.kind];
+
+    // TOTAL
+    component.total += props.completion.usage.total_tokens;
+
+    // PROMPT
+    component.input.total += props.completion.usage.prompt_tokens;
+    props.completion.usage.prompt_tokens_details?.audio_tokens ?? 0;
+    component.input.cached +=
+      props.completion.usage.prompt_tokens_details?.cached_tokens ?? 0;
+
+    // COMPLETION
+    component.output.total += props.completion.usage.total_tokens;
+    component.output.accepted_prediction +=
+      props.completion.usage.completion_tokens_details
+        ?.accepted_prediction_tokens ?? 0;
+    component.output.reasoning +=
+      props.completion.usage.completion_tokens_details?.reasoning_tokens ?? 0;
+    component.output.rejected_prediction +=
+      props.completion.usage.completion_tokens_details
+        ?.rejected_prediction_tokens ?? 0;
+
+    //----
+    // RE-AGGREGATE
+    //----
+    const sum = (getter: (comp: IAgenticaTokenUsage.IComponent) => number) =>
+      Object.entries(props.usage)
+        .filter(([key]) => key !== "aggregate")
+        .map(([_, comp]) => getter(comp))
+        .reduce((a, b) => a + b, 0);
+    const aggregate: IAgenticaTokenUsage.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 plus = (
+    x: IAgenticaTokenUsage,
+    y: IAgenticaTokenUsage,
+  ): IAgenticaTokenUsage => {
+    const component = (
+      a: IAgenticaTokenUsage.IComponent,
+      b: IAgenticaTokenUsage.IComponent,
+    ): IAgenticaTokenUsage.IComponent => ({
+      total: a.total + b.total,
+      input: {
+        total: a.input.total + b.input.total,
+        cached: a.input.cached + b.input.cached,
+      },
+      output: {
+        total: a.output.total + b.output.total,
+        reasoning: a.output.reasoning + b.output.reasoning,
+        accepted_prediction:
+          a.output.accepted_prediction + b.output.accepted_prediction,
+        rejected_prediction:
+          a.output.rejected_prediction + b.output.rejected_prediction,
+      },
+    });
+    return {
+      aggregate: component(x.aggregate, y.aggregate),
+      initialize: component(x.initialize, y.initialize),
+      select: component(x.select, y.select),
+      cancel: component(x.cancel, y.cancel),
+      call: component(x.call, y.call),
+      describe: component(x.describe, y.describe),
+    };
+  };
+
+  export const zero = (): IAgenticaTokenUsage => {
+    const component = (): IAgenticaTokenUsage.IComponent => ({
+      total: 0,
+      input: {
+        total: 0,
+        cached: 0,
+      },
+      output: {
+        total: 0,
+        reasoning: 0,
+        accepted_prediction: 0,
+        rejected_prediction: 0,
+      },
+    });
+    return {
+      aggregate: component(),
+      initialize: component(),
+      select: component(),
+      cancel: component(),
+      call: component(),
+      describe: component(),
+    };
+  };
+}

package/src/internal/MathUtil.ts

@@ -1,3 +1,3 @@
-export namespace MathUtil {
-  export const round = (value: number): number => Math.floor(value * 100) / 100;
-}
+export namespace MathUtil {
+  export const round = (value: number): number => Math.floor(value * 100) / 100;
+}

package/src/internal/Singleton.ts

@@ -1,22 +1,22 @@
-/**
- * @internal
- */
-export class Singleton<T, Args extends any[] = []> {
-  private readonly closure_: (...args: Args) => T;
-  private value_: T | object;
-
-  public constructor(closure: (...args: Args) => T) {
-    this.closure_ = closure;
-    this.value_ = NOT_MOUNTED_YET;
-  }
-
-  public get(...args: Args): T {
-    if (this.value_ === NOT_MOUNTED_YET) this.value_ = this.closure_(...args);
-    return this.value_ as T;
-  }
-}
-
-/**
- * @internal
- */
-const NOT_MOUNTED_YET = {};
+/**
+ * @internal
+ */
+export class Singleton<T, Args extends any[] = []> {
+  private readonly closure_: (...args: Args) => T;
+  private value_: T | object;
+
+  public constructor(closure: (...args: Args) => T) {
+    this.closure_ = closure;
+    this.value_ = NOT_MOUNTED_YET;
+  }
+
+  public get(...args: Args): T {
+    if (this.value_ === NOT_MOUNTED_YET) this.value_ = this.closure_(...args);
+    return this.value_ as T;
+  }
+}
+
+/**
+ * @internal
+ */
+const NOT_MOUNTED_YET = {};

package/src/internal/__map_take.ts

@@ -1,15 +1,15 @@
-/**
- * @internal
- */
-export const __map_take = <Key, T>(
-  dict: Map<Key, T>,
-  key: Key,
-  generator: () => T,
-): T => {
-  const oldbie: T | undefined = dict.get(key);
-  if (oldbie) return oldbie;
-
-  const value: T = generator();
-  dict.set(key, value);
-  return value;
-};
+/**
+ * @internal
+ */
+export const __map_take = <Key, T>(
+  dict: Map<Key, T>,
+  key: Key,
+  generator: () => T,
+): T => {
+  const oldbie: T | undefined = dict.get(key);
+  if (oldbie) return oldbie;
+
+  const value: T = generator();
+  dict.set(key, value);
+  return value;
+};