typia 7.0.0-dev.20241114 → 7.0.0-dev.20241122

package/src/internal/_isUniqueItems.ts

@@ -0,0 +1,159 @@
+export const _isUniqueItems = (elements: any[]): boolean => {
+  // EMTPY OR ONLY ONE
+  if (elements.length < 2) return true;
+
+  // SHALLOW COMPARISON
+  if (["boolean", "bigint", "number", "string"].includes(typeof elements[0]))
+    return new Set(elements).size === elements.length;
+
+  // DEEP COMPARISON
+  for (let i = 0; i < elements.length; i++)
+    for (let j = i + 1; j < elements.length; j++)
+      if (equals(new WeakMap())(elements[i], elements[j])) return false;
+  return true;
+};
+
+const equals = (visited: WeakMap<object, WeakMap<object, boolean>>) => {
+  const next = (a: any, b: any): boolean => {
+    // SHALLOW EQUAL
+    if (a === b) return true;
+    else if (typeof a !== typeof b || typeof a !== "object") return false;
+    // COMPARE CONTAINERS
+    else if (Array.isArray(a))
+      return Array.isArray(b) && a.map((x, i) => next(x, b[i])).every((x) => x);
+    else if (a instanceof Set)
+      return (
+        b instanceof Set && a.size === b.size && [...a].every((x) => b.has(x))
+      );
+    else if (a instanceof Map)
+      return (
+        b instanceof Map &&
+        a.size === b.size &&
+        [...a].every(([k, v]) => b.has(k) && next(v, b.get(k)))
+      );
+    // ATOMIC CLASSES
+    else if (a instanceof Boolean)
+      return b instanceof Boolean
+        ? a.valueOf() === b.valueOf()
+        : a.valueOf() === b;
+    else if (a instanceof BigInt)
+      return b instanceof BigInt ? a === b : a === BigInt(b);
+    else if (a instanceof Number)
+      return b instanceof Number
+        ? a.valueOf() === b.valueOf()
+        : a.valueOf() === b;
+    else if (a instanceof String)
+      return b instanceof String
+        ? a.valueOf() === b.valueOf()
+        : a.valueOf() === b;
+    else if (a instanceof Date)
+      return b instanceof Date && a.getTime() === b.getTime();
+    // BINARY DATA
+    else if (a instanceof Uint8Array)
+      return (
+        b instanceof Uint8Array &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof Uint8ClampedArray)
+      return (
+        b instanceof Uint8ClampedArray &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof Uint16Array)
+      return (
+        b instanceof Uint16Array &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof Uint32Array)
+      return (
+        b instanceof Uint32Array &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof BigUint64Array)
+      return (
+        b instanceof BigUint64Array &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof Int8Array)
+      return (
+        b instanceof Int8Array &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof Int16Array)
+      return (
+        b instanceof Int16Array &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof Int32Array)
+      return (
+        b instanceof Int32Array &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof BigInt64Array)
+      return (
+        b instanceof BigInt64Array &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof Float32Array)
+      return (
+        b instanceof Float32Array &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof Float64Array)
+      return (
+        b instanceof Float64Array &&
+        a.length === b.length &&
+        a.every((x, i) => x === b[i])
+      );
+    else if (a instanceof ArrayBuffer) {
+      if (!(b instanceof ArrayBuffer) || a.byteLength !== b.byteLength)
+        return false;
+      const x: Uint8Array = new Uint8Array(a);
+      const y: Uint8Array = new Uint8Array(b);
+      return x.every((v, i) => v === y[i]);
+    } else if (a instanceof SharedArrayBuffer) {
+      if (!(b instanceof SharedArrayBuffer) || a.byteLength !== b.byteLength)
+        return false;
+      const x: Uint8Array = new Uint8Array(a);
+      const y: Uint8Array = new Uint8Array(b);
+      return x.every((v, i) => v === y[i]);
+    } else if (a instanceof DataView) {
+      if (!(b instanceof DataView) || a.byteLength !== b.byteLength)
+        return false;
+      const x: Uint8Array = new Uint8Array(a.buffer);
+      const y: Uint8Array = new Uint8Array(b.buffer);
+      return x.every((v, i) => v === y[i]);
+    } else if (a instanceof File)
+      return (
+        b instanceof File &&
+        a.name === b.name &&
+        a.size === b.size &&
+        a.type === b.type &&
+        next(a.slice(), b.slice())
+      );
+    // JUST PLAIN OBJECTS
+    else if (a !== null && b !== null) {
+      if (visited.has(a) && visited.get(a)!.has(b))
+        return visited.get(a)!.get(b)!;
+      if (!visited.has(a)) visited.set(a, new WeakMap());
+      visited.get(a)!.set(b, true);
+      const res: boolean =
+        Object.keys(a).length === Object.keys(b).length &&
+        Object.keys(a).every((x) => next(a[x], b[x]));
+      visited.get(a)!.set(b, res);
+      return res;
+    }
+    return false;
+  };
+  return next;
+};

package/src/internal/_llmApplicationFinalize.ts

@@ -3,17 +3,36 @@ import { HttpLlmConverter } from "@samchon/openapi/lib/converters/HttpLlmConvert
 
 export const _llmApplicationFinalize = <Model extends ILlmApplication.Model>(
   app: ILlmApplication<Model>,
-  options?: ILlmApplication.IOptions<Model>,
+  options?: Partial<ILlmApplication.IOptions<Model>>,
 ): void => {
-  app.options = {
-    separate: options?.separate ?? null,
-    recursive: app.model === "chatgpt" ? undefined : (3 as any),
-  };
+  app.options = (
+    isChatGptOptions(app, options)
+      ? ({
+          separate: options?.separate ?? null,
+          reference: options?.reference ?? false,
+          constraint: options?.constraint ?? false,
+        } satisfies ILlmApplication.IOptions<"chatgpt">)
+      : ({
+          separate: (options?.separate ??
+            null) as ILlmApplication.ICommonOptions<
+            Exclude<Model, "chatgpt">
+          >["separate"],
+          recursive:
+            (options as ILlmApplication.IOptions<"3.0"> | undefined)
+              ?.recursive ?? 3,
+        } satisfies ILlmApplication.ICommonOptions<Exclude<Model, "chatgpt">>)
+  ) as ILlmApplication.IOptions<Model>;
   if (app.options.separate === null) return;
   for (const func of app.functions)
     func.separated = HttpLlmConverter.separateParameters({
       model: app.model,
       parameters: func.parameters,
-      predicate: app.options.separate,
+      predicate: app.options
+        .separate as ILlmApplication.IOptions<Model>["separate"] as any,
     });
 };
+
+const isChatGptOptions = <Model extends ILlmApplication.Model>(
+  app: ILlmApplication<Model>,
+  _options: unknown,
+): _options is ILlmApplication.IOptions<"chatgpt"> => app.model === "chatgpt";

package/src/llm.ts

@@ -1,4 +1,4 @@
-import { ILlmApplication } from "@samchon/openapi";
+import { IChatGptSchema, ILlmApplication } from "@samchon/openapi";
 
 /**
  * > You must configure the generic argument `App`.
@@ -82,7 +82,7 @@ export function application(
  */
 export function application<
   App extends object,
-  Model extends ILlmApplication.Model = "3.1",
+  Model extends ILlmApplication.Model,
 >(
   options?: Partial<Omit<ILlmApplication.IOptions<Model>, "recursive">>,
 ): ILlmApplication<Model>;
@@ -164,14 +164,14 @@ export function schema(): never;
  *
  * @template T Target type
  * @template Model LLM schema model
+ * @param $defs Definitions of named schemas if the model is `chatgpt`
  * @returns LLM schema
  * @reference https://platform.openai.com/docs/guides/function-calling
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function schema<
-  T,
-  Model extends ILlmApplication.Model = "3.1",
->(): ILlmApplication.ModelSchema[Model];
+export function schema<T, Model extends ILlmApplication.Model>(
+  ...$defs: Model extends "chatgpt" ? [Record<string, IChatGptSchema>] : []
+): ILlmApplication.ModelSchema[Model];
 
 /**
  * @internal

package/src/programmers/llm/LlmApplicationProgrammer.ts

@@ -1,13 +1,18 @@
-import { ILlmApplication } from "@samchon/openapi";
+import { IChatGptSchema, ILlmApplication, OpenApi } from "@samchon/openapi";
+import { ChatGptConverter } from "@samchon/openapi/lib/converters/ChatGptConverter";
+import { GeminiConverter } from "@samchon/openapi/lib/converters/GeminiConverter";
+import { LlmConverterV3 } from "@samchon/openapi/lib/converters/LlmConverterV3";
+import { LlmConverterV3_1 } from "@samchon/openapi/lib/converters/LlmConverterV3_1";
 import { ILlmFunction } from "@samchon/openapi/lib/structures/ILlmFunction";
 
 import { MetadataFactory } from "../../factories/MetadataFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataFunction } from "../../schemas/metadata/MetadataFunction";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
+import { IJsonApplication } from "../../module";
+import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
 import { LlmSchemaProgrammer } from "./LlmSchemaProgrammer";
 
 export namespace LlmApplicationProgrammer {
@@ -101,175 +106,190 @@ export namespace LlmApplicationProgrammer {
     if (errors.length)
       throw new Error("Failed to write LLM application: " + errors.join("\n"));
 
-    const object: MetadataObjectType = props.metadata.objects[0]!.type;
+    const application: IJsonApplication<"3.1"> =
+      JsonApplicationProgrammer.write({
+        version: "3.1",
+        metadata: props.metadata,
+      });
     return {
       model: props.model,
-      functions: object.properties
-        .filter(
-          (p) =>
-            p.value.functions.length === 1 &&
-            p.value.size() === 1 &&
-            p.key.isSoleLiteral(),
-        )
-        .filter(
-          (p) => p.jsDocTags.find((tag) => tag.name === "hidden") === undefined,
-        )
-        .map((p) =>
-          writeFunction({
-            model: props.model,
-            name: p.key.getSoleLiteral()!,
-            function: p.value.functions[0]!,
-            description: p.description,
-            jsDocTags: p.jsDocTags,
-          }),
-        ),
-      options: {
-        separate: null,
-        recursive: props.model === "chatgpt" ? undefined : (3 as any),
-      },
-    };
-  };
-
-  const writeFunction = <Model extends ILlmApplication.Model>(props: {
-    model: Model;
-    name: string;
-    function: MetadataFunction;
-    description: string | null;
-    jsDocTags: IJsDocTagInfo[];
-  }): ILlmFunction<ILlmApplication.ModelSchema[Model]> => {
-    const deprecated: boolean = props.jsDocTags.some(
-      (tag) => tag.name === "deprecated",
-    );
-    const tags: string[] = props.jsDocTags
-      .map((tag) =>
-        tag.name === "tag"
-          ? (tag.text?.filter((elem) => elem.kind === "text") ?? [])
-          : [],
-      )
-      .flat()
-      .map((elem) => elem.text)
-      .map((str) => str.trim().split(" ")[0] ?? "")
-      .filter((str) => !!str.length);
-    return {
-      name: props.name,
-      parameters: props.function.parameters.map((p) => {
-        const jsDocTagDescription: string | null = writeDescriptionFromJsDocTag(
-          {
-            jsDocTags: p.jsDocTags,
-            name: "param",
-            parameter: p.name,
-          },
-        );
-        return writeSchema({
+      functions: application.functions.map((func) =>
+        writeFunction({
           model: props.model,
-          metadata: p.type,
-          description: jsDocTagDescription ?? p.description,
-          jsDocTags: jsDocTagDescription ? [] : p.jsDocTags,
-        });
-      }),
-      output:
-        props.function.output.size() || props.function.output.nullable
-          ? writeSchema({
-              model: props.model,
-              metadata: props.function.output,
-              description:
-                writeDescriptionFromJsDocTag({
-                  jsDocTags: props.jsDocTags,
-                  name: "return",
-                }) ??
-                writeDescriptionFromJsDocTag({
-                  jsDocTags: props.jsDocTags,
-                  name: "returns",
-                }),
-              jsDocTags: [],
-            })
-          : undefined,
-      description: props.description ?? undefined,
-      deprecated: deprecated || undefined,
-      tags: tags.length ? tags : undefined,
+          components: application.components,
+          function: func,
+        }),
+      ),
+      options: (props.model === "chatgpt"
+        ? ({
+            separate: null,
+            reference: false,
+            constraint: false,
+          } satisfies ILlmApplication.IOptions<"chatgpt">)
+        : ({
+            separate: null,
+            recursive: props.model === "chatgpt" ? undefined : (3 as any),
+          } satisfies ILlmApplication.ICommonOptions<
+            Exclude<Model, "chatgpt">
+          >)) as ILlmApplication.IOptions<Model>,
     };
   };
 
-  const writeSchema = <Model extends ILlmApplication.Model>(props: {
+  const writeFunction = <Model extends ILlmApplication.Model>(props: {
     model: Model;
-    metadata: Metadata;
-    description: string | null;
-    jsDocTags: IJsDocTagInfo[];
-  }): ILlmApplication.ModelSchema[Model] => {
-    const schema: ILlmApplication.ModelSchema[Model] =
-      LlmSchemaProgrammer.write(props);
-    const explicit: Pick<
-      ILlmApplication.ModelSchema[Model],
-      "title" | "description"
-    > = writeDescription({
+    components: OpenApi.IComponents;
+    function: IJsonApplication.IFunction<OpenApi.IJsonSchema>;
+  }): ILlmFunction<ILlmApplication.ModelParameters[Model]> => {
+    const parameters: ILlmApplication.ModelParameters[Model] =
+      writeParameters(props);
+    const output: ILlmApplication.ModelSchema[Model] | null = writeOutput({
       model: props.model,
-      description: props.description,
-      jsDocTags: props.jsDocTags,
+      parameters,
+      components: props.components,
+      schema: props.function.output?.schema ?? null,
     });
+    if (
+      output &&
+      output.description === undefined &&
+      !!props.function.output?.description?.length
+    )
+      output.description = props.function.output.description;
     return {
-      ...schema,
-      ...(!!explicit.title?.length || !!explicit.description?.length
-        ? explicit
-        : {}),
+      name: props.function.name,
+      parameters,
+      output: (output ?? undefined) as
+        | ILlmApplication.ModelParameters[Model]["properties"][string]
+        | undefined,
+      description: (() => {
+        if (
+          !props.function.summary?.length ||
+          !props.function.description?.length
+        )
+          return props.function.summary || props.function.description;
+        const summary: string = props.function.summary.endsWith(".")
+          ? props.function.summary.slice(0, -1)
+          : props.function.summary;
+        return props.function.description.startsWith(summary)
+          ? props.function.description
+          : summary + ".\n\n" + props.function.description;
+      })(),
+      deprecated: props.function.deprecated,
+      tags: props.function.tags,
+      strict: true,
     };
   };
 
-  const writeDescription = <Model extends ILlmApplication.Model>(props: {
+  const writeParameters = <Model extends ILlmApplication.Model>(props: {
     model: Model;
-    description: string | null;
-    jsDocTags: IJsDocTagInfo[];
-  }): Pick<ILlmApplication.ModelSchema[Model], "title" | "description"> => {
-    const title: string | undefined = (() => {
-      const [explicit] = getJsDocTexts({
-        jsDocTags: props.jsDocTags,
-        name: "title",
-      });
-      if (explicit?.length) return explicit;
-      else if (!props.description?.length) return undefined;
-
-      const index: number = props.description.indexOf("\n");
-      const top: string = (
-        index === -1 ? props.description : props.description.substring(0, index)
-      ).trim();
-      return top.endsWith(".") ? top.substring(0, top.length - 1) : undefined;
+    components: OpenApi.IComponents;
+    function: IJsonApplication.IFunction<OpenApi.IJsonSchema>;
+  }): ILlmApplication.ModelParameters[Model] => {
+    const schema: OpenApi.IJsonSchema.IObject = {
+      type: "object",
+      properties: Object.fromEntries(
+        props.function.parameters.map((p) => [
+          p.name,
+          {
+            ...p.schema,
+            title: p.title ?? p.schema.title,
+            description: p.description ?? p.schema.description,
+          },
+        ]),
+      ),
+      required: props.function.parameters
+        .filter((p) => p.required)
+        .map((p) => p.name),
+      additionalProperties: false,
+    };
+    const parameters: ILlmApplication.ModelParameters[Model] | null = (() => {
+      if (props.model === "chatgpt")
+        return ChatGptConverter.parameters({
+          options: DEFAULT_CHATGPT_OPTION,
+          components: props.components,
+          schema,
+        });
+      else if (props.model === "gemini")
+        return GeminiConverter.parameters({
+          recursive: DEFAULT_V3_OPTIONS.recursive,
+          components: props.components,
+          schema,
+        }) as ILlmApplication.ModelParameters[Model] | null;
+      else if (props.model === "3.0")
+        return LlmConverterV3.parameters({
+          recursive: DEFAULT_V3_OPTIONS.recursive,
+          components: props.components,
+          schema,
+        }) as ILlmApplication.ModelParameters[Model] | null;
+      else if (props.model === "3.1")
+        return LlmConverterV3_1.parameters({
+          recursive: DEFAULT_V3_OPTIONS.recursive,
+          components: props.components,
+          schema,
+        }) as ILlmApplication.ModelParameters[Model] | null;
+      else return null;
     })();
-    return {
-      title: title,
-      description: props.description?.length ? props.description : undefined,
-    } as any;
+    if (parameters === null)
+      throw new Error("Failed to write LLM application parameters.");
+    return parameters;
   };
 
-  const writeDescriptionFromJsDocTag = (props: {
-    jsDocTags: IJsDocTagInfo[];
-    name: string;
-    parameter?: string;
-  }): string | null => {
-    const parametric: (elem: IJsDocTagInfo) => boolean = props.parameter
-      ? (tag) =>
-          tag.text!.find(
-            (elem) =>
-              elem.kind === "parameterName" && elem.text === props.parameter,
-          ) !== undefined
-      : () => true;
-    const tag: IJsDocTagInfo | undefined = props.jsDocTags.find(
-      (tag) => tag.name === props.name && tag.text && parametric(tag),
-    );
-    return tag && tag.text
-      ? (tag.text.find((elem) => elem.kind === "text")?.text ?? null)
-      : null;
+  const writeOutput = <Model extends ILlmApplication.Model>(props: {
+    model: Model;
+    parameters: ILlmApplication.ModelParameters[Model];
+    components: OpenApi.IComponents;
+    schema: OpenApi.IJsonSchema | null;
+  }): ILlmApplication.ModelSchema[Model] | null => {
+    if (props.schema === null) return null;
+    const output: ILlmApplication.ModelSchema[Model] | null = (() => {
+      if (props.model === "chatgpt") {
+        const $defs =
+          (props.parameters as IChatGptSchema.IParameters).$defs ?? {};
+        const output: IChatGptSchema | null = ChatGptConverter.schema({
+          options: DEFAULT_CHATGPT_OPTION,
+          components: props.components,
+          $defs,
+          schema: props.schema,
+        });
+        if (
+          output !== null &&
+          (props.parameters as IChatGptSchema.IParameters).$defs ===
+            undefined &&
+          Object.keys($defs).length !== 0
+        )
+          (props.parameters as IChatGptSchema.IParameters).$defs = $defs;
+        return output;
+      } else if (props.model === "gemini")
+        return GeminiConverter.schema({
+          recursive: DEFAULT_V3_OPTIONS.recursive,
+          components: props.components,
+          schema: props.schema,
+        }) as ILlmApplication.ModelSchema[Model] | null;
+      else if (props.model === "3.0")
+        return LlmConverterV3.schema({
+          recursive: DEFAULT_V3_OPTIONS.recursive,
+          components: props.components,
+          schema: props.schema,
+        }) as ILlmApplication.ModelSchema[Model] | null;
+      else if (props.model === "3.1")
+        return LlmConverterV3_1.schema({
+          recursive: DEFAULT_V3_OPTIONS.recursive,
+          components: props.components,
+          schema: props.schema,
+        }) as ILlmApplication.ModelSchema[Model] | null;
+      else return null;
+    })();
+    if (output === null)
+      throw new Error("Failed to write LLM application output.");
+    return output;
   };
-
-  const getJsDocTexts = (props: {
-    jsDocTags: IJsDocTagInfo[];
-    name: string;
-  }): string[] =>
-    props.jsDocTags
-      .filter(
-        (tag) =>
-          tag.name === props.name &&
-          tag.text &&
-          tag.text.find((elem) => elem.kind === "text" && elem.text.length) !==
-            undefined,
-      )
-      .map((tag) => tag.text!.find((elem) => elem.kind === "text")!.text);
 }
+
+const DEFAULT_CHATGPT_OPTION: ILlmApplication.IChatGptOptions = {
+  separate: null,
+  reference: false,
+  constraint: false,
+};
+const DEFAULT_V3_OPTIONS = {
+  separate: null,
+  recursive: 3,
+} satisfies ILlmApplication.ICommonOptions<"3.0">;