@agentica/core 0.12.2-dev.20250314 → 0.12.2

package/src/internal/AgenticaDefaultPrompt.ts

@@ -1,43 +1,43 @@
-import { ILlmSchema } from "@samchon/openapi";
-
-import { IAgenticaConfig } from "../structures/IAgenticaConfig";
-import { AgenticaSystemPrompt } from "./AgenticaSystemPrompt";
-import { Singleton } from "./Singleton";
-
-export namespace AgenticaDefaultPrompt {
-  export const write = <Model extends ILlmSchema.Model>(
-    config?: IAgenticaConfig<Model>,
-  ): string => {
-    if (config?.systemPrompt?.common)
-      return config?.systemPrompt?.common(config);
-
-    const locale: string = config?.locale ?? getLocale.get();
-    const timezone: string = config?.timezone ?? getTimezone.get();
-
-    return AgenticaSystemPrompt.COMMON.replace("${locale}", locale).replace(
-      "${timezone}",
-      timezone,
-    );
-  };
-}
-
-const getLocale = new Singleton(() =>
-  isNode.get()
-    ? (process.env.LANG?.split(".")[0] ?? "en-US")
-    : navigator.language,
-);
-
-const getTimezone = new Singleton(
-  () => Intl.DateTimeFormat().resolvedOptions().timeZone,
-);
-
-const isNode = new Singleton(() => {
-  const isObject = (obj: any) => typeof obj === "object" && obj !== null;
-  return (
-    typeof global === "object" &&
-    isObject(global) &&
-    isObject(global.process) &&
-    isObject(global.process.versions) &&
-    typeof global.process.versions.node !== "undefined"
-  );
-});
+import { ILlmSchema } from "@samchon/openapi";
+
+import { IAgenticaConfig } from "../structures/IAgenticaConfig";
+import { AgenticaSystemPrompt } from "./AgenticaSystemPrompt";
+import { Singleton } from "./Singleton";
+
+export namespace AgenticaDefaultPrompt {
+  export const write = <Model extends ILlmSchema.Model>(
+    config?: IAgenticaConfig<Model>,
+  ): string => {
+    if (config?.systemPrompt?.common)
+      return config?.systemPrompt?.common(config);
+
+    const locale: string = config?.locale ?? getLocale.get();
+    const timezone: string = config?.timezone ?? getTimezone.get();
+
+    return AgenticaSystemPrompt.COMMON.replace("${locale}", locale).replace(
+      "${timezone}",
+      timezone,
+    );
+  };
+}
+
+const getLocale = new Singleton(() =>
+  isNode.get()
+    ? (process.env.LANG?.split(".")[0] ?? "en-US")
+    : navigator.language,
+);
+
+const getTimezone = new Singleton(
+  () => Intl.DateTimeFormat().resolvedOptions().timeZone,
+);
+
+const isNode = new Singleton(() => {
+  const isObject = (obj: any) => typeof obj === "object" && obj !== null;
+  return (
+    typeof global === "object" &&
+    isObject(global) &&
+    isObject(global.process) &&
+    isObject(global.process.versions) &&
+    typeof global.process.versions.node !== "undefined"
+  );
+});

package/src/internal/AgenticaOperationComposer.ts

@@ -1,96 +1,96 @@
-import { ILlmSchema } from "@samchon/openapi";
-
-import { AgenticaOperation } from "../context/AgenticaOperation";
-import { AgenticaOperationCollection } from "../context/AgenticaOperationCollection";
-import { IAgenticaConfig } from "../structures/IAgenticaConfig";
-import { IAgenticaController } from "../structures/IAgenticaController";
-import { __map_take } from "./__map_take";
-
-export namespace AgenticaOperationComposer {
-  export const compose = <Model extends ILlmSchema.Model>(props: {
-    controllers: IAgenticaController<Model>[];
-    config?: IAgenticaConfig<Model> | undefined;
-  }): AgenticaOperationCollection<Model> => {
-    const unique: boolean =
-      props.controllers.length === 1 ||
-      (() => {
-        const names: string[] = props.controllers
-          .map((controller) =>
-            controller.application.functions.map((func) => func.name),
-          )
-          .flat();
-        return new Set(names).size === names.length;
-      })();
-    const naming = (func: string, ci: number) =>
-      unique ? func : `_${ci}_${func}`;
-
-    const array: AgenticaOperation<Model>[] = props.controllers
-      .map((controller, ci) =>
-        controller.protocol === "http"
-          ? controller.application.functions.map(
-              (func) =>
-                ({
-                  protocol: "http",
-                  controller: controller,
-                  function: func,
-                  name: naming(func.name, ci),
-                  toJSON: () => ({
-                    protocol: "http",
-                    controller: controller.name,
-                    function: func.name,
-                    name: naming(func.name, ci),
-                  }),
-                }) satisfies AgenticaOperation.Http<Model>,
-            )
-          : controller.application.functions.map(
-              (func) =>
-                ({
-                  protocol: "class",
-                  controller,
-                  function: func,
-                  name: naming(func.name, ci),
-                  toJSON: () => ({
-                    protocol: "class",
-                    controller: controller.name,
-                    function: func.name,
-                    name: naming(func.name, ci),
-                  }),
-                }) satisfies AgenticaOperation.Class<Model>,
-            ),
-      )
-      .flat();
-    const divided: AgenticaOperation<Model>[][] | undefined =
-      !!props.config?.capacity && array.length > props.config.capacity
-        ? divideOperations({
-            array,
-            capacity: props.config.capacity,
-          })
-        : undefined;
-
-    const flat: Map<string, AgenticaOperation<Model>> = new Map();
-    const group: Map<string, Map<string, AgenticaOperation<Model>>> = 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,
-    };
-  };
-
-  const divideOperations = <Model extends ILlmSchema.Model>(props: {
-    array: AgenticaOperation<Model>[];
-    capacity: number;
-  }): AgenticaOperation<Model>[][] => {
-    const size: number = Math.ceil(props.array.length / props.capacity);
-    const capacity: number = Math.ceil(props.array.length / size);
-    const replica: AgenticaOperation<Model>[] = props.array.slice();
-    return new Array(size).fill(0).map(() => replica.splice(0, capacity));
-  };
-}
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AgenticaOperation } from "../context/AgenticaOperation";
+import { AgenticaOperationCollection } from "../context/AgenticaOperationCollection";
+import { IAgenticaConfig } from "../structures/IAgenticaConfig";
+import { IAgenticaController } from "../structures/IAgenticaController";
+import { __map_take } from "./__map_take";
+
+export namespace AgenticaOperationComposer {
+  export const compose = <Model extends ILlmSchema.Model>(props: {
+    controllers: IAgenticaController<Model>[];
+    config?: IAgenticaConfig<Model> | undefined;
+  }): AgenticaOperationCollection<Model> => {
+    const unique: boolean =
+      props.controllers.length === 1 ||
+      (() => {
+        const names: string[] = props.controllers
+          .map((controller) =>
+            controller.application.functions.map((func) => func.name),
+          )
+          .flat();
+        return new Set(names).size === names.length;
+      })();
+    const naming = (func: string, ci: number) =>
+      unique ? func : `_${ci}_${func}`;
+
+    const array: AgenticaOperation<Model>[] = props.controllers
+      .map((controller, ci) =>
+        controller.protocol === "http"
+          ? controller.application.functions.map(
+              (func) =>
+                ({
+                  protocol: "http",
+                  controller: controller,
+                  function: func,
+                  name: naming(func.name, ci),
+                  toJSON: () => ({
+                    protocol: "http",
+                    controller: controller.name,
+                    function: func.name,
+                    name: naming(func.name, ci),
+                  }),
+                }) satisfies AgenticaOperation.Http<Model>,
+            )
+          : controller.application.functions.map(
+              (func) =>
+                ({
+                  protocol: "class",
+                  controller,
+                  function: func,
+                  name: naming(func.name, ci),
+                  toJSON: () => ({
+                    protocol: "class",
+                    controller: controller.name,
+                    function: func.name,
+                    name: naming(func.name, ci),
+                  }),
+                }) satisfies AgenticaOperation.Class<Model>,
+            ),
+      )
+      .flat();
+    const divided: AgenticaOperation<Model>[][] | undefined =
+      !!props.config?.capacity && array.length > props.config.capacity
+        ? divideOperations({
+            array,
+            capacity: props.config.capacity,
+          })
+        : undefined;
+
+    const flat: Map<string, AgenticaOperation<Model>> = new Map();
+    const group: Map<string, Map<string, AgenticaOperation<Model>>> = 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,
+    };
+  };
+
+  const divideOperations = <Model extends ILlmSchema.Model>(props: {
+    array: AgenticaOperation<Model>[];
+    capacity: number;
+  }): AgenticaOperation<Model>[][] => {
+    const size: number = Math.ceil(props.array.length / props.capacity);
+    const capacity: number = Math.ceil(props.array.length / size);
+    const replica: AgenticaOperation<Model>[] = props.array.slice();
+    return new Array(size).fill(0).map(() => replica.splice(0, capacity));
+  };
+}

package/src/internal/ByteArrayUtil.ts

@@ -1,5 +1,5 @@
-export namespace ByteArrayUtil {
-  export const toUtf8 = (byteArray: Uint8Array): string => {
-    return new TextDecoder().decode(byteArray);
-  };
-}
+export namespace ByteArrayUtil {
+  export const toUtf8 = (byteArray: Uint8Array): string => {
+    return new TextDecoder().decode(byteArray);
+  };
+}

package/src/internal/MPSCUtil.ts

@@ -1,111 +1,111 @@
-export namespace MPSCUtil {
-  export interface Output<T> {
-    consumer: ReadableStream<T>;
-    produce: (chunk: T) => void;
-    close: () => void;
-    /**
-     * Wait until the producing is finished.
-     */
-    waitClosed: () => Promise<void>;
-    /**
-     * Wait until the consuming is finished.(finished producing and consuming)
-     */
-    waitUntilEmpty: () => Promise<void>;
-
-    /**
-     * Check if producing is done and consuming is finished.
-     */
-    done: () => boolean;
-  }
-
-  export const create = <T>(): Output<T> => {
-    const queue = new AsyncQueue<T>();
-    const consumer = new ReadableStream<T>({
-      async pull(controller) {
-        const { value, done } = await queue.dequeue();
-        if (done) {
-          controller.close();
-        } else {
-          controller.enqueue(value);
-        }
-      },
-    });
-
-    return {
-      consumer,
-      produce: (chunk: T) => queue.enqueue(chunk),
-      close: () => queue.close(),
-      done: () => queue.done(),
-      waitClosed: () => queue.waitClosed(),
-      waitUntilEmpty: () => queue.waitUntilEmpty(),
-    };
-  };
-
-  export class AsyncQueue<T> {
-    private queue: T[] = [];
-    private resolvers: ((value: IteratorResult<T, undefined>) => void)[] = [];
-    private closeResolvers: (() => void)[] = [];
-    private emptyResolvers: (() => void)[] = [];
-    private closed = false;
-
-    enqueue(item: T) {
-      this.queue.push(item);
-      if (this.resolvers.length > 0) {
-        this.resolvers.shift()?.({ value: this.queue.shift()!, done: false });
-      }
-    }
-
-    async dequeue(): Promise<IteratorResult<T, undefined>> {
-      if (this.queue.length > 0) {
-        return { value: this.queue.shift()!, done: false };
-      }
-      if (this.closed) {
-        if (this.emptyResolvers.length > 0) {
-          this.emptyResolvers.forEach((resolve) => resolve());
-          this.emptyResolvers = [];
-        }
-        return { value: undefined, done: true };
-      }
-      return new Promise((resolve) => this.resolvers.push(resolve));
-    }
-
-    isEmpty() {
-      return this.queue.length === 0;
-    }
-
-    isClosed() {
-      return this.closed;
-    }
-
-    done() {
-      return this.isClosed() && this.isEmpty();
-    }
-
-    close() {
-      this.closed = true;
-      while (this.resolvers.length > 0) {
-        this.resolvers.shift()?.({ value: undefined, done: true });
-      }
-      this.closeResolvers.forEach((resolve) => resolve());
-    }
-
-    waitUntilEmpty() {
-      if (this.isEmpty()) {
-        return Promise.resolve();
-      }
-      return new Promise<void>((resolve) => {
-        this.emptyResolvers.push(resolve);
-      });
-    }
-
-    waitClosed() {
-      if (this.isClosed()) {
-        return Promise.resolve();
-      }
-
-      return new Promise<void>((resolve) => {
-        this.closeResolvers.push(resolve);
-      });
-    }
-  }
-}
+export namespace MPSCUtil {
+  export interface Output<T> {
+    consumer: ReadableStream<T>;
+    produce: (chunk: T) => void;
+    close: () => void;
+    /**
+     * Wait until the producing is finished.
+     */
+    waitClosed: () => Promise<void>;
+    /**
+     * Wait until the consuming is finished.(finished producing and consuming)
+     */
+    waitUntilEmpty: () => Promise<void>;
+
+    /**
+     * Check if producing is done and consuming is finished.
+     */
+    done: () => boolean;
+  }
+
+  export const create = <T>(): Output<T> => {
+    const queue = new AsyncQueue<T>();
+    const consumer = new ReadableStream<T>({
+      async pull(controller) {
+        const { value, done } = await queue.dequeue();
+        if (done) {
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      },
+    });
+
+    return {
+      consumer,
+      produce: (chunk: T) => queue.enqueue(chunk),
+      close: () => queue.close(),
+      done: () => queue.done(),
+      waitClosed: () => queue.waitClosed(),
+      waitUntilEmpty: () => queue.waitUntilEmpty(),
+    };
+  };
+
+  export class AsyncQueue<T> {
+    private queue: T[] = [];
+    private resolvers: ((value: IteratorResult<T, undefined>) => void)[] = [];
+    private closeResolvers: (() => void)[] = [];
+    private emptyResolvers: (() => void)[] = [];
+    private closed = false;
+
+    enqueue(item: T) {
+      this.queue.push(item);
+      if (this.resolvers.length > 0) {
+        this.resolvers.shift()?.({ value: this.queue.shift()!, done: false });
+      }
+    }
+
+    async dequeue(): Promise<IteratorResult<T, undefined>> {
+      if (this.queue.length > 0) {
+        return { value: this.queue.shift()!, done: false };
+      }
+      if (this.closed) {
+        if (this.emptyResolvers.length > 0) {
+          this.emptyResolvers.forEach((resolve) => resolve());
+          this.emptyResolvers = [];
+        }
+        return { value: undefined, done: true };
+      }
+      return new Promise((resolve) => this.resolvers.push(resolve));
+    }
+
+    isEmpty() {
+      return this.queue.length === 0;
+    }
+
+    isClosed() {
+      return this.closed;
+    }
+
+    done() {
+      return this.isClosed() && this.isEmpty();
+    }
+
+    close() {
+      this.closed = true;
+      while (this.resolvers.length > 0) {
+        this.resolvers.shift()?.({ value: undefined, done: true });
+      }
+      this.closeResolvers.forEach((resolve) => resolve());
+    }
+
+    waitUntilEmpty() {
+      if (this.isEmpty()) {
+        return Promise.resolve();
+      }
+      return new Promise<void>((resolve) => {
+        this.emptyResolvers.push(resolve);
+      });
+    }
+
+    waitClosed() {
+      if (this.isClosed()) {
+        return Promise.resolve();
+      }
+
+      return new Promise<void>((resolve) => {
+        this.closeResolvers.push(resolve);
+      });
+    }
+  }
+}

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 = {};