typia 7.2.0 → 7.2.1-dev.20241212

package/src/programmers/llm/LlmSchemaProgrammer.ts

@@ -1,143 +1,143 @@
-import { ILlmSchema, IOpenApiSchemaError, IResult } from "@samchon/openapi";
-import { LlmSchemaComposer } from "@samchon/openapi/lib/composers/LlmSchemaComposer";
-
-import { IJsonSchemaCollection } from "../../schemas/json/IJsonSchemaCollection";
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { AtomicPredicator } from "../helpers/AtomicPredicator";
-import { json_schema_bigint } from "../internal/json_schema_bigint";
-import { json_schema_boolean } from "../internal/json_schema_boolean";
-import { json_schema_native } from "../internal/json_schema_native";
-import { json_schema_number } from "../internal/json_schema_number";
-import { json_schema_string } from "../internal/json_schema_string";
-import { JsonSchemasProgrammer } from "../json/JsonSchemasProgrammer";
-
-export namespace LlmSchemaProgrammer {
-  export interface IOutput<Model extends ILlmSchema.Model> {
-    model: Model;
-    schema: ILlmSchema.ModelSchema[Model];
-    $defs: Record<string, ILlmSchema.ModelSchema[Model]>;
-  }
-
-  export const write = <Model extends ILlmSchema.Model>(props: {
-    model: Model;
-    metadata: Metadata;
-    config?: Partial<ILlmSchema.ModelConfig[Model]>;
-  }): IOutput<Model> => {
-    const collection: IJsonSchemaCollection<"3.1"> =
-      JsonSchemasProgrammer.write({
-        version: "3.1",
-        metadatas: [props.metadata],
-      });
-
-    const $defs: Record<string, ILlmSchema.ModelSchema[Model]> = {};
-    const result: IResult<ILlmSchema.ModelSchema[Model], IOpenApiSchemaError> =
-      LlmSchemaComposer.schema(props.model)({
-        config: {
-          ...LlmSchemaComposer.defaultConfig(props.model),
-          ...props.config,
-        } as any,
-        components: collection.components,
-        schema: collection.schemas[0]!,
-        $defs: $defs as any,
-      }) as IResult<ILlmSchema.ModelSchema[Model], IOpenApiSchemaError>;
-    if (result.success === false)
-      throw new TransformerError({
-        code: "typia.llm.schema",
-        message:
-          "failed to convert JSON schema to LLM schema.\n\n" +
-          result.error.reasons
-            .map((r) => `  - ${r.accessor}: ${r.message}`)
-            .join("\n"),
-      });
-    return {
-      model: props.model,
-      $defs,
-      schema: result.value,
-    };
-  };
-
-  export const validate =
-    (model: ILlmSchema.Model) =>
-    (metadata: Metadata): string[] => {
-      const output: string[] = [];
-      if (
-        metadata.atomics.some((a) => a.type === "bigint") ||
-        metadata.constants.some((c) => c.type === "bigint")
-      )
-        output.push("LLM schema does not support bigint type.");
-      if (
-        (model === "chatgpt" || model === "gemini") &&
-        metadata.objects.some((o) =>
-          o.type.properties.some(
-            (p) => p.key.isSoleLiteral() === false && p.value.size() !== 0,
-          ),
-        )
-      )
-        output.push(
-          `LLM schema of "${model}" does not support dynamic property in object.`,
-        );
-      if (
-        metadata.tuples.some((t) =>
-          t.type.elements.some((e) => e.isRequired() === false),
-        ) ||
-        metadata.arrays.some((a) => a.type.value.isRequired() === false)
-      )
-        output.push("LLM schema does not support undefined type in array.");
-      if (metadata.maps.length)
-        output.push("LLM schema does not support Map type.");
-      if (metadata.sets.length)
-        output.push("LLM schema does not support Set type.");
-      for (const native of metadata.natives)
-        if (
-          AtomicPredicator.native(native.name) === false &&
-          native.name !== "Date" &&
-          native.name !== "Blob" &&
-          native.name !== "File"
-        )
-          output.push(`LLM schema does not support ${native.name} type.`);
-      if (model === "gemini" && size(metadata) > 1)
-        output.push("Gemini model does not support the union type.");
-      return output;
-    };
-}
-
-const size = (metadata: Metadata): number =>
-  (metadata.escaped ? size(metadata.escaped.returns) : 0) +
-  metadata.aliases.length +
-  metadata.objects.length +
-  metadata.arrays.length +
-  metadata.tuples.length +
-  (metadata.maps.length ? 1 : 0) +
-  (metadata.sets.length ? 1 : 0) +
-  metadata.atomics
-    .map((a) =>
-      a.type === "boolean"
-        ? json_schema_boolean(a).length
-        : a.type === "bigint"
-          ? json_schema_bigint(a).length
-          : a.type === "number"
-            ? json_schema_number(a).length
-            : json_schema_string(a).length,
-    )
-    .reduce((a, b) => a + b, 0) +
-  metadata.constants.filter(
-    (c) => metadata.atomics.some((a) => a.type === c.type) === false,
-  ).length +
-  metadata.templates.length +
-  metadata.natives
-    .filter(
-      (n) =>
-        metadata.atomics.some((a) => a.type === n.name) === false &&
-        metadata.constants.some((c) => c.type === n.name) === false,
-    )
-    .map(
-      (n) =>
-        json_schema_native({
-          components: {},
-          native: n,
-        }).length,
-    )
-    .reduce((a, b) => a + b, 0);
+import { ILlmSchema, IOpenApiSchemaError, IResult } from "@samchon/openapi";
+import { LlmSchemaComposer } from "@samchon/openapi/lib/composers/LlmSchemaComposer";
+
+import { IJsonSchemaCollection } from "../../schemas/json/IJsonSchemaCollection";
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { AtomicPredicator } from "../helpers/AtomicPredicator";
+import { json_schema_bigint } from "../internal/json_schema_bigint";
+import { json_schema_boolean } from "../internal/json_schema_boolean";
+import { json_schema_native } from "../internal/json_schema_native";
+import { json_schema_number } from "../internal/json_schema_number";
+import { json_schema_string } from "../internal/json_schema_string";
+import { JsonSchemasProgrammer } from "../json/JsonSchemasProgrammer";
+
+export namespace LlmSchemaProgrammer {
+  export interface IOutput<Model extends ILlmSchema.Model> {
+    model: Model;
+    schema: ILlmSchema.ModelSchema[Model];
+    $defs: Record<string, ILlmSchema.ModelSchema[Model]>;
+  }
+
+  export const write = <Model extends ILlmSchema.Model>(props: {
+    model: Model;
+    metadata: Metadata;
+    config?: Partial<ILlmSchema.ModelConfig[Model]>;
+  }): IOutput<Model> => {
+    const collection: IJsonSchemaCollection<"3.1"> =
+      JsonSchemasProgrammer.write({
+        version: "3.1",
+        metadatas: [props.metadata],
+      });
+
+    const $defs: Record<string, ILlmSchema.ModelSchema[Model]> = {};
+    const result: IResult<ILlmSchema.ModelSchema[Model], IOpenApiSchemaError> =
+      LlmSchemaComposer.schema(props.model)({
+        config: {
+          ...LlmSchemaComposer.defaultConfig(props.model),
+          ...props.config,
+        } as any,
+        components: collection.components,
+        schema: collection.schemas[0]!,
+        $defs: $defs as any,
+      }) as IResult<ILlmSchema.ModelSchema[Model], IOpenApiSchemaError>;
+    if (result.success === false)
+      throw new TransformerError({
+        code: "typia.llm.schema",
+        message:
+          "failed to convert JSON schema to LLM schema.\n\n" +
+          result.error.reasons
+            .map((r) => `  - ${r.accessor}: ${r.message}`)
+            .join("\n"),
+      });
+    return {
+      model: props.model,
+      $defs,
+      schema: result.value,
+    };
+  };
+
+  export const validate =
+    (model: ILlmSchema.Model) =>
+    (metadata: Metadata): string[] => {
+      const output: string[] = [];
+      if (
+        metadata.atomics.some((a) => a.type === "bigint") ||
+        metadata.constants.some((c) => c.type === "bigint")
+      )
+        output.push("LLM schema does not support bigint type.");
+      if (
+        (model === "chatgpt" || model === "gemini") &&
+        metadata.objects.some((o) =>
+          o.type.properties.some(
+            (p) => p.key.isSoleLiteral() === false && p.value.size() !== 0,
+          ),
+        )
+      )
+        output.push(
+          `LLM schema of "${model}" does not support dynamic property in object.`,
+        );
+      if (
+        metadata.tuples.some((t) =>
+          t.type.elements.some((e) => e.isRequired() === false),
+        ) ||
+        metadata.arrays.some((a) => a.type.value.isRequired() === false)
+      )
+        output.push("LLM schema does not support undefined type in array.");
+      if (metadata.maps.length)
+        output.push("LLM schema does not support Map type.");
+      if (metadata.sets.length)
+        output.push("LLM schema does not support Set type.");
+      for (const native of metadata.natives)
+        if (
+          AtomicPredicator.native(native.name) === false &&
+          native.name !== "Date" &&
+          native.name !== "Blob" &&
+          native.name !== "File"
+        )
+          output.push(`LLM schema does not support ${native.name} type.`);
+      if (model === "gemini" && size(metadata) > 1)
+        output.push("Gemini model does not support the union type.");
+      return output;
+    };
+}
+
+const size = (metadata: Metadata): number =>
+  (metadata.escaped ? size(metadata.escaped.returns) : 0) +
+  metadata.aliases.length +
+  metadata.objects.length +
+  metadata.arrays.length +
+  metadata.tuples.length +
+  (metadata.maps.length ? 1 : 0) +
+  (metadata.sets.length ? 1 : 0) +
+  metadata.atomics
+    .map((a) =>
+      a.type === "boolean"
+        ? json_schema_boolean(a).length
+        : a.type === "bigint"
+          ? json_schema_bigint(a).length
+          : a.type === "number"
+            ? json_schema_number(a).length
+            : json_schema_string(a).length,
+    )
+    .reduce((a, b) => a + b, 0) +
+  metadata.constants.filter(
+    (c) => metadata.atomics.some((a) => a.type === c.type) === false,
+  ).length +
+  metadata.templates.length +
+  metadata.natives
+    .filter(
+      (n) =>
+        metadata.atomics.some((a) => a.type === n.name) === false &&
+        metadata.constants.some((c) => c.type === n.name) === false,
+    )
+    .map(
+      (n) =>
+        json_schema_native({
+          components: {},
+          native: n,
+        }).length,
+    )
+    .reduce((a, b) => a + b, 0);

package/src/programmers/misc/MiscAssertCloneProgrammer.ts

@@ -1,95 +1,95 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
-
-export namespace MiscAssertCloneProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-    init?: ts.Expression | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
-      ...props,
-      config: {
-        equals: false,
-        guard: false,
-      },
-    });
-    const clone: FeatureProgrammer.IDecomposed = MiscCloneProgrammer.decompose({
-      ...props,
-      validated: true,
-    });
-    return {
-      functions: {
-        ...assert.functions,
-        ...clone.functions,
-      },
-      statements: [
-        ...assert.statements,
-        ...clone.statements,
-        StatementFactory.constant({
-          name: "__assert",
-          value: assert.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__clone",
-          value: clone.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter({
-            context: props.context,
-            init: props.init,
-          }),
-        ],
-        clone.arrow.type,
-        undefined,
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__clone"),
-          undefined,
-          [
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("__assert"),
-              undefined,
-              [
-                ts.factory.createIdentifier("input"),
-                AssertProgrammer.Guardian.identifier(),
-              ],
-            ),
-          ],
-        ),
-      ),
-    };
-  };
-
-  export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      ...props,
-      functor,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
+
+export namespace MiscAssertCloneProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+    init?: ts.Expression | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
+      ...props,
+      config: {
+        equals: false,
+        guard: false,
+      },
+    });
+    const clone: FeatureProgrammer.IDecomposed = MiscCloneProgrammer.decompose({
+      ...props,
+      validated: true,
+    });
+    return {
+      functions: {
+        ...assert.functions,
+        ...clone.functions,
+      },
+      statements: [
+        ...assert.statements,
+        ...clone.statements,
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__clone",
+          value: clone.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
+        ],
+        clone.arrow.type,
+        undefined,
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__clone"),
+          undefined,
+          [
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("__assert"),
+              undefined,
+              [
+                ts.factory.createIdentifier("input"),
+                AssertProgrammer.Guardian.identifier(),
+              ],
+            ),
+          ],
+        ),
+      ),
+    };
+  };
+
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      functor,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+}