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

package/src/programmers/llm/LlmSchemaProgrammer.ts

@@ -1,5 +1,13 @@
-import { ILlmApplication } from "@samchon/openapi";
-import { HttpLlmConverter } from "@samchon/openapi/lib/converters/HttpLlmConverter";
+import {
+  IChatGptSchema,
+  IHttpLlmApplication,
+  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 { IJsonSchemaCollection } from "../../schemas/json/IJsonSchemaCollection";
 import { Metadata } from "../../schemas/metadata/Metadata";
@@ -13,25 +21,42 @@ import { json_schema_string } from "../internal/json_schema_string";
 import { JsonSchemasProgrammer } from "../json/JsonSchemasProgrammer";
 
 export namespace LlmSchemaProgrammer {
+  export interface IOutput<Model extends ILlmApplication.Model> {
+    model: Model;
+    schema: ILlmApplication.ModelSchema[Model];
+    $defs: Record<string, IChatGptSchema>;
+  }
   export const write = <Model extends ILlmApplication.Model>(props: {
     model: Model;
     metadata: Metadata;
-  }): ILlmApplication.ModelSchema[Model] => {
+  }): IOutput<Model> => {
     const collection: IJsonSchemaCollection<"3.1"> =
       JsonSchemasProgrammer.write({
         version: "3.1",
         metadatas: [props.metadata],
       });
-    const schema: ILlmApplication.ModelSchema[Model] | null =
-      HttpLlmConverter.schema({
-        model: props.model,
-        components: collection.components,
-        schema: collection.schemas[0]!,
+
+    const $defs: Record<string, IChatGptSchema> = {};
+    const schema: ILlmApplication.ModelSchema[Model] | null = CASTERS[
+      props.model
+    ]({
+      options: {
         recursive: 3,
-      });
+        reference: false,
+        constraint: false,
+      } satisfies Omit<ILlmApplication.IChatGptOptions, "separate"> &
+        Omit<ILlmApplication.ICommonOptions<any>, "separate"> as any,
+      components: collection.components,
+      schema: collection.schemas[0]!,
+      $defs,
+    }) as ILlmApplication.ModelSchema[Model] | null;
     if (schema === null)
       throw new Error("Failed to convert JSON schema to LLM schema.");
-    return schema;
+    return {
+      model: props.model,
+      $defs,
+      schema,
+    };
   };
 
   export const validate =
@@ -64,13 +89,6 @@ export namespace LlmSchemaProgrammer {
           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.");
-      // if (
-      //   metadata.aliases.some((a) => a.type.recursive) ||
-      //   metadata.arrays.some((a) => a.type.recursive) ||
-      //   metadata.objects.some((o) => o.type.recursive) ||
-      //   metadata.tuples.some((t) => t.type.recursive)
-      // )
-      //   output.push("LLM schema does not support recursive type.");
       return output;
     };
 }
@@ -112,3 +130,48 @@ const size = (metadata: Metadata): number =>
         }).length,
     )
     .reduce((a, b) => a + b, 0);
+
+const CASTERS = {
+  "3.0": (props: {
+    components: OpenApi.IComponents;
+    schema: OpenApi.IJsonSchema;
+    options: IHttpLlmApplication.IOptions<"3.0">;
+  }) =>
+    LlmConverterV3.schema({
+      components: props.components,
+      schema: props.schema,
+      recursive: props.options.recursive,
+    }),
+  "3.1": (props: {
+    components: OpenApi.IComponents;
+    schema: OpenApi.IJsonSchema;
+    options: IHttpLlmApplication.IOptions<"3.1">;
+  }) =>
+    LlmConverterV3_1.schema({
+      components: props.components,
+      schema: props.schema,
+      recursive: props.options.recursive,
+    }),
+  chatgpt: (props: {
+    components: OpenApi.IComponents;
+    schema: OpenApi.IJsonSchema;
+    $defs: Record<string, IChatGptSchema>;
+    options: Omit<IHttpLlmApplication.IChatGptOptions, "separate">;
+  }) =>
+    ChatGptConverter.schema({
+      components: props.components,
+      schema: props.schema,
+      $defs: props.$defs,
+      options: props.options,
+    }),
+  gemini: (props: {
+    components: OpenApi.IComponents;
+    schema: OpenApi.IJsonSchema;
+    options: IHttpLlmApplication.IOptions<"gemini">;
+  }) =>
+    GeminiConverter.schema({
+      components: props.components,
+      schema: props.schema,
+      recursive: props.options.recursive,
+    }),
+};

package/src/tags/Format.ts

@@ -1,50 +1,50 @@
-import type { TagBase } from "./TagBase";
-
-export type Format<Value extends Format.Value> = TagBase<{
-  target: "string";
-  kind: "format";
-  value: Value;
-  validate: `$importInternal("isFormat${PascalizeString<Value>}")($input)`;
-  exclusive: ["format", "pattern"];
-  schema: {
-    format: Value;
-  };
-}>;
-export namespace Format {
-  export type Value =
-    | "byte"
-    | "password"
-    | "regex"
-    | "uuid"
-    | "email"
-    | "hostname"
-    | "idn-email"
-    | "idn-hostname"
-    | "iri"
-    | "iri-reference"
-    | "ipv4"
-    | "ipv6"
-    | "uri"
-    | "uri-reference"
-    | "uri-template"
-    | "url"
-    | "date-time"
-    | "date"
-    | "time"
-    | "duration"
-    | "json-pointer"
-    | "relative-json-pointer";
-}
-
-type PascalizeString<Key extends string> = Key extends `-${infer R}`
-  ? `${PascalizeString<R>}`
-  : Key extends `${infer _F}-${infer _R}`
-    ? PascalizeSnakeString<Key>
-    : Capitalize<Key>;
-type PascalizeSnakeString<Key extends string> = Key extends `-${infer R}`
-  ? PascalizeSnakeString<R>
-  : Key extends `${infer F}${infer M}-${infer R}`
-    ? `${Uppercase<F>}${Lowercase<M>}${PascalizeSnakeString<R>}`
-    : Key extends `${infer F}${infer R}`
-      ? `${Uppercase<F>}${Lowercase<R>}`
-      : Key;
+import type { TagBase } from "./TagBase";
+
+export type Format<Value extends Format.Value> = TagBase<{
+  target: "string";
+  kind: "format";
+  value: Value;
+  validate: `$importInternal("isFormat${PascalizeString<Value>}")($input)`;
+  exclusive: ["format", "pattern"];
+  schema: {
+    format: Value;
+  };
+}>;
+export namespace Format {
+  export type Value =
+    | "byte"
+    | "password"
+    | "regex"
+    | "uuid"
+    | "email"
+    | "hostname"
+    | "idn-email"
+    | "idn-hostname"
+    | "iri"
+    | "iri-reference"
+    | "ipv4"
+    | "ipv6"
+    | "uri"
+    | "uri-reference"
+    | "uri-template"
+    | "url"
+    | "date-time"
+    | "date"
+    | "time"
+    | "duration"
+    | "json-pointer"
+    | "relative-json-pointer";
+}
+
+type PascalizeString<Key extends string> = Key extends `-${infer R}`
+  ? `${PascalizeString<R>}`
+  : Key extends `${infer _F}-${infer _R}`
+    ? PascalizeSnakeString<Key>
+    : Capitalize<Key>;
+type PascalizeSnakeString<Key extends string> = Key extends `-${infer R}`
+  ? PascalizeSnakeString<R>
+  : Key extends `${infer F}${infer M}-${infer R}`
+    ? `${Uppercase<F>}${Lowercase<M>}${PascalizeSnakeString<R>}`
+    : Key extends `${infer F}${infer R}`
+      ? `${Uppercase<F>}${Lowercase<R>}`
+      : Key;

package/src/tags/Type.ts

@@ -1,32 +1,32 @@
-import { TagBase } from "./TagBase";
-
-export type Type<
-  Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double",
-> = TagBase<{
-  target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
-  kind: "type";
-  value: Value;
-  validate: Value extends "int32"
-    ? `$importInternal("isTypeInt32")($input)`
-    : Value extends "uint32"
-      ? `$importInternal("isTypeUint32")($input)`
-      : Value extends "int64"
-        ? {
-            number: `$importInternal("isTypeInt64")($input)`;
-            bigint: `true`;
-          }
-        : Value extends "uint64"
-          ? {
-              number: `$importInternal("isTypeUint64")($input)`;
-              bigint: `BigInt(0) <= $input`;
-            }
-          : Value extends "float"
-            ? `$importInternal("isTypeFloat")($input)`
-            : `true`;
-  exclusive: true;
-  schema: {
-    type: Value extends "int32" | "uint32" | "int64" | "uint64"
-      ? "integer"
-      : "number";
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+export type Type<
+  Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double",
+> = TagBase<{
+  target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
+  kind: "type";
+  value: Value;
+  validate: Value extends "int32"
+    ? `$importInternal("isTypeInt32")($input)`
+    : Value extends "uint32"
+      ? `$importInternal("isTypeUint32")($input)`
+      : Value extends "int64"
+        ? {
+            number: `$importInternal("isTypeInt64")($input)`;
+            bigint: `true`;
+          }
+        : Value extends "uint64"
+          ? {
+              number: `$importInternal("isTypeUint64")($input)`;
+              bigint: `BigInt(0) <= $input`;
+            }
+          : Value extends "float"
+            ? `$importInternal("isTypeFloat")($input)`
+            : `true`;
+  exclusive: true;
+  schema: {
+    type: Value extends "int32" | "uint32" | "int64" | "uint64"
+      ? "integer"
+      : "number";
+  };
+}>;

package/src/tags/UniqueItems.ts

@@ -5,7 +5,7 @@ export type UniqueItems<Value extends boolean = true> = TagBase<{
   kind: "uniqueItems";
   value: Value;
   validate: Value extends true
-    ? `$input.length <= 1 || ($input.length === new Set($input).size)`
+    ? `$importInternal("isUniqueItems")($input)`
     : undefined;
   exclusive: true;
   schema: {

package/src/transformers/features/llm/LlmSchemaTransformer.ts

@@ -1,6 +1,7 @@
 import { ILlmApplication } from "@samchon/openapi";
 import ts from "typescript";
 
+import { IdentifierFactory } from "../../../factories/IdentifierFactory";
 import { LiteralFactory } from "../../../factories/LiteralFactory";
 import { MetadataCollection } from "../../../factories/MetadataCollection";
 import { MetadataFactory } from "../../../factories/MetadataFactory";
@@ -66,12 +67,45 @@ export namespace LlmSchemaTransformer {
       });
 
     // GENERATE LLM SCHEMA
-    const schema: ILlmApplication.ModelSchema[ILlmApplication.Model] =
-      LlmSchemaProgrammer.write({
-        model,
-        metadata: result.data,
-      });
-    return LiteralFactory.write(schema);
+    const out: LlmSchemaProgrammer.IOutput<any> = LlmSchemaProgrammer.write({
+      model,
+      metadata: result.data,
+    });
+    if (Object.keys(out.$defs).length === 0)
+      return LiteralFactory.write(out.schema);
+    return ts.factory.createCallExpression(
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "$defs",
+            ts.factory.createTypeReferenceNode("Record<string, unknown>"),
+            undefined,
+          ),
+        ],
+        undefined,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ts.factory.createExpressionStatement(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Object.assign"),
+                undefined,
+                [
+                  ts.factory.createIdentifier("$defs"),
+                  LiteralFactory.write(out.$defs),
+                ],
+              ),
+            ),
+            ts.factory.createReturnStatement(LiteralFactory.write(out.schema)),
+          ],
+          true,
+        ),
+      ),
+      undefined,
+      [props.expression.arguments[0]!],
+    );
   };
 
   const get_parameter =