typia 10.0.2 → 11.0.0

package/src/programmers/llm/LlmSchemaProgrammer.ts

@@ -1,10 +1,4 @@
-import {
-  IChatGptSchema,
-  ILlmSchema,
-  ILlmSchemaV3,
-  IOpenApiSchemaError,
-  IResult,
-} from "@samchon/openapi";
+import { ILlmSchema, IOpenApiSchemaError, IResult } from "@samchon/openapi";
 import { LlmSchemaComposer } from "@samchon/openapi/lib/composers/LlmSchemaComposer";
 
 import { IJsonSchemaCollection } from "../../schemas/json/IJsonSchemaCollection";
@@ -21,34 +15,29 @@ 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 interface IOutput {
+    schema: ILlmSchema;
+    $defs: Record<string, ILlmSchema>;
   }
 
-  export const write = <Model extends ILlmSchema.Model>(props: {
-    model: Model;
+  export const write = (props: {
     metadata: Metadata;
-    config?: Partial<ILlmSchema.ModelConfig[Model]>;
-  }): IOutput<Model> => {
+    config?: Partial<ILlmSchema.IConfig>;
+  }): IOutput => {
     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,
+    const $defs: Record<string, ILlmSchema> = {};
+    const result: IResult<ILlmSchema, IOpenApiSchemaError> =
+      LlmSchemaComposer.schema({
+        config: LlmSchemaComposer.getConfig(props.config),
         components: collection.components,
         schema: collection.schemas[0]!,
-        $defs: $defs as any,
-      }) as IResult<ILlmSchema.ModelSchema[Model], IOpenApiSchemaError>;
+        $defs,
+      });
     if (result.success === false)
       throw new TransformerError({
         code: "typia.llm.schema",
@@ -59,92 +48,64 @@ export namespace LlmSchemaProgrammer {
             .join("\n"),
       });
     return {
-      model: props.model,
       $defs,
       schema: result.value,
     };
   };
 
-  export const validate =
-    <Model extends ILlmSchema.Model>(props: {
-      model: ILlmSchema.Model;
-      config?: Partial<ILlmSchema.ModelConfig[Model]>;
-    }) =>
-    (metadata: Metadata): string[] => {
-      const output: string[] = [];
+  export const validate = (props: {
+    config?: Partial<ILlmSchema.IConfig>;
+    metadata: Metadata;
+  }): string[] => {
+    const output: string[] = [];
 
-      // no additionalProperties in ChatGPT strict mode or Gemini
-      if (
-        props.model === "chatgpt" &&
-        (props.config as Partial<IChatGptSchema.IConfig> | undefined)
-          ?.strict === true &&
-        metadata.objects.some((o) =>
-          o.type.properties.some(
-            (p) => p.key.isSoleLiteral() === false && p.value.size() !== 0,
-          ),
-        )
+    // no additionalProperties in OpenAI strict mode
+    const config: ILlmSchema.IConfig = LlmSchemaComposer.getConfig(
+      props.config,
+    );
+    if (
+      config.strict === true &&
+      props.metadata.objects.some((o) =>
+        o.type.properties.some(
+          (p) => p.key.isSoleLiteral() === false && p.value.size() !== 0,
+        ),
       )
-        output.push(
-          `LLM schema of "${props.model}"${props.model === "chatgpt" ? " (strict mode)" : ""} does not support dynamic property in object.`,
-        );
+    )
+      output.push(`Strict mode does not allow dynamic property in object.`);
 
-      // ChatGPT strict mode even does not support the optional property
-      if (
-        props.model === "chatgpt" &&
-        (props.config as Partial<IChatGptSchema.IConfig> | undefined)
-          ?.strict === true &&
-        metadata.objects.some((o) =>
-          o.type.properties.some((p) => p.value.isRequired() === false),
-        )
+    // OpenAI strict mode even does not support the optional property
+    if (
+      config.strict === true &&
+      props.metadata.objects.some((o) =>
+        o.type.properties.some((p) => p.value.isRequired() === false),
       )
-        output.push(
-          `LLM schema of "chatgpt" (strict mode) does not support optional property in object.`,
-        );
-
-      // no recursive rule of Gemini and V3
-      if (
-        props.model === "3.0" &&
-        ((props.config as ILlmSchemaV3.IConfig | undefined)?.recursive ===
-          false ||
-          (props.config as ILlmSchemaV3.IConfig | undefined)?.recursive === 0)
-      ) {
-        if (metadata.objects.some((o) => o.type.recursive))
-          output.push(
-            `LLM schema of "${props.model}" does not support recursive object.`,
-          );
-        if (metadata.arrays.some((a) => a.type.recursive))
-          output.push(
-            `LLM schema of "${props.model}" does not support recursive array.`,
-          );
-      }
+    )
+      output.push(`Strict mode does not support optional property in object.`);
 
-      // just JSON rule
-      if (
-        metadata.atomics.some((a) => a.type === "bigint") ||
-        metadata.constants.some((c) => c.type === "bigint")
-      )
-        output.push("LLM schema does not support bigint type.");
+    // just JSON rule
+    if (
+      props.metadata.atomics.some((a) => a.type === "bigint") ||
+      props.metadata.constants.some((c) => c.type === "bigint")
+    )
+      output.push("LLM schema does not support bigint type.");
+    if (props.metadata.tuples.length !== 0)
+      output.push("LLM schema does not support tuple type.");
+    if (props.metadata.arrays.some((a) => a.type.value.isRequired() === false))
+      output.push("LLM schema does not support undefined type in array.");
+    if (props.metadata.maps.length)
+      output.push("LLM schema does not support Map type.");
+    if (props.metadata.sets.length)
+      output.push("LLM schema does not support Set type.");
+    for (const native of props.metadata.natives)
       if (
-        metadata.tuples.some((t) =>
-          t.type.elements.some((e) => e.isRequired() === false),
-        ) ||
-        metadata.arrays.some((a) => a.type.value.isRequired() === false)
+        AtomicPredicator.native(native.name) === false &&
+        native.name !== "Date" &&
+        native.name !== "Blob" &&
+        native.name !== "File"
       )
-        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.`);
-      return output;
-    };
+        output.push(`LLM schema does not support ${native.name} type.`);
+    return output;
+  };
 }
 
 const size = (metadata: Metadata): number =>

package/src/schemas/metadata/IMetadataProperty.ts

@@ -6,4 +6,5 @@ export interface IMetadataProperty {
   value: IMetadata;
   description: string | null;
   jsDocTags: IJsDocTagInfo[];
+  mutability?: "readonly" | null | undefined;
 }

package/src/schemas/metadata/MetadataProperty.ts

@@ -11,6 +11,7 @@ export class MetadataProperty {
   public readonly value: Metadata;
   public readonly description: string | null;
   public readonly jsDocTags: IJsDocTagInfo[];
+  public readonly mutability?: "readonly" | null | undefined;
 
   public of_protobuf_?: IProtobufProperty;
 
@@ -23,6 +24,7 @@ export class MetadataProperty {
     this.value = props.value;
     this.description = props.description;
     this.jsDocTags = props.jsDocTags;
+    this.mutability = props.mutability;
   }
 
   /** @internal */
@@ -39,6 +41,7 @@ export class MetadataProperty {
       value: Metadata.from(property.value, dict),
       description: property.description,
       jsDocTags: property.jsDocTags.slice(),
+      mutability: property.mutability,
     });
   }
 
@@ -48,6 +51,7 @@ export class MetadataProperty {
       value: this.value.toJSON(),
       description: this.description,
       jsDocTags: this.jsDocTags,
+      mutability: this.mutability,
     };
   }
 }

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

@@ -10,7 +10,7 @@ import { StatementFactory } from "../../../factories/StatementFactory";
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
 import { LlmApplicationProgrammer } from "../../../programmers/llm/LlmApplicationProgrammer";
-import { LlmModelPredicator } from "../../../programmers/llm/LlmModelPredicator";
+import { LlmMetadataFactory } from "../../../programmers/llm/LlmMetadataFactory";
 
 import { ValidationPipe } from "../../../typings/ValidationPipe";
 
@@ -28,14 +28,10 @@ export namespace LlmApplicationTransformer {
       props.context.importer.type({
         file: "@samchon/openapi",
         name: "ILlmApplication",
-        arguments: [
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral(dec.application.model),
-          ),
-        ],
+        arguments: [dec.node],
       }),
     );
-    if (!props.expression.arguments?.[0]) return literal;
+    if (props.expression.arguments?.[0] === undefined) return literal;
     return ExpressionFactory.selfCall(
       ts.factory.createBlock(
         [
@@ -49,7 +45,6 @@ export namespace LlmApplicationTransformer {
               value: ts.factory.createIdentifier("application"),
               argument: props.expression.arguments[0]!,
               equals: dec.config?.equals,
-              model: dec.application.model,
             }),
           ),
           ts.factory.createReturnStatement(
@@ -66,7 +61,7 @@ export namespace LlmApplicationTransformer {
     method: string,
     props: ITransformProps,
   ): {
-    application: ILlmApplication<ILlmSchema.Model>;
+    application: ILlmApplication;
     type: ts.Type;
     node: ts.TypeNode;
     config:
@@ -87,22 +82,16 @@ export namespace LlmApplicationTransformer {
     if (ts.isTypeNode(top) === false) return null;
 
     // GET TYPE
-    const model: ILlmSchema.Model = LlmModelPredicator.getModel({
-      checker: props.context.checker,
-      method,
-      node: props.expression.typeArguments[1],
-    });
     const config:
       | Partial<
           ILlmSchema.IConfig & {
             equals: boolean;
           }
         >
-      | undefined = LlmModelPredicator.getConfig({
+      | undefined = LlmMetadataFactory.getConfig({
       context: props.context,
       method,
-      model,
-      node: props.expression.typeArguments[2],
+      node: props.expression.typeArguments[1],
     });
     const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
 
@@ -119,10 +108,12 @@ export namespace LlmApplicationTransformer {
             functional: true,
             validate:
               validate === true
-                ? LlmApplicationProgrammer.validate({
-                    model,
-                    config,
-                  })
+                ? (metadata, explore) =>
+                    LlmApplicationProgrammer.validate({
+                      config,
+                      metadata,
+                      explore,
+                    })
                 : undefined,
           },
           collection: new MetadataCollection({
@@ -142,7 +133,6 @@ export namespace LlmApplicationTransformer {
     // GENERATE LLM APPLICATION
     return {
       application: LlmApplicationProgrammer.write({
-        model,
         context: props.context,
         modulo: props.modulo,
         metadata: analyze(false),
@@ -160,7 +150,6 @@ export namespace LlmApplicationTransformer {
     value: ts.Expression;
     argument: ts.Expression;
     equals?: boolean;
-    model: ILlmSchema.Model;
   }) => {
     const satisfiesTypeNode: ts.TypeNode = ts.factory.createTypeReferenceNode(
       ts.factory.createIdentifier("Partial"),
@@ -175,13 +164,9 @@ export namespace LlmApplicationTransformer {
               undefined,
               ts.factory.createQualifiedName(
                 ts.factory.createIdentifier("ILlmApplication"),
-                ts.factory.createIdentifier("IOptions"),
+                ts.factory.createIdentifier("IConfig"),
               ),
-              [
-                ts.factory.createLiteralTypeNode(
-                  ts.factory.createStringLiteral(props.model),
-                ),
-              ],
+              undefined,
               false,
             ),
             ts.factory.createUnionTypeNode([

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

@@ -28,11 +28,6 @@ export namespace LlmControllerTransformer {
       props.context.importer.type({
         file: "@samchon/openapi",
         name: "ILlmApplication",
-        arguments: [
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral(dec.application.model),
-          ),
-        ],
       }),
     );
     const value: ts.Expression = ts.factory.createObjectLiteralExpression(
@@ -68,7 +63,6 @@ export namespace LlmControllerTransformer {
                     value: ts.factory.createIdentifier("application"),
                     argument: props.expression.arguments[2]!,
                     equals: dec.config?.equals,
-                    model: dec.application.model,
                   }),
                 ),
               ]
@@ -80,12 +74,7 @@ export namespace LlmControllerTransformer {
       props.context.importer.type({
         file: "@samchon/openapi",
         name: "ILlmController",
-        arguments: [
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral(dec.application.model),
-          ),
-          dec.node,
-        ],
+        arguments: [dec.node],
       }),
     );
   };

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

@@ -1,5 +1,4 @@
 import { ILlmSchema } from "@samchon/openapi";
-import { ILlmFunction } from "@samchon/openapi/lib/structures/ILlmFunction";
 import ts from "typescript";
 
 import { LiteralFactory } from "../../../factories/LiteralFactory";
@@ -8,7 +7,7 @@ import { MetadataFactory } from "../../../factories/MetadataFactory";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
-import { LlmModelPredicator } from "../../../programmers/llm/LlmModelPredicator";
+import { LlmMetadataFactory } from "../../../programmers/llm/LlmMetadataFactory";
 import { LlmParametersProgrammer } from "../../../programmers/llm/LlmParametersProgrammer";
 
 import { ValidationPipe } from "../../../typings/ValidationPipe";
@@ -31,16 +30,10 @@ export namespace LlmParametersTransformer {
     if (ts.isTypeNode(top) === false) return props.expression;
 
     // GET TYPE
-    const model: ILlmSchema.Model = LlmModelPredicator.getModel({
-      checker: props.context.checker,
-      method: "parameters",
-      node: props.expression.typeArguments[1],
-    });
-    const config: Partial<ILlmSchema.IConfig> = LlmModelPredicator.getConfig({
+    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
       context: props.context,
       method: "parameters",
-      model,
-      node: props.expression.typeArguments[2],
+      node: props.expression.typeArguments[1],
     }) as Partial<ILlmSchema.IConfig>;
 
     const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
@@ -57,10 +50,12 @@ export namespace LlmParametersTransformer {
             constant: true,
             validate:
               validate === true
-                ? LlmParametersProgrammer.validate({
-                    model,
-                    config,
-                  })
+                ? (metadata, explore) =>
+                    LlmParametersProgrammer.validate({
+                      config,
+                      metadata,
+                      explore,
+                    })
                 : undefined,
           },
           collection: new MetadataCollection({
@@ -78,8 +73,7 @@ export namespace LlmParametersTransformer {
     analyze(true);
 
     // GENERATE LLM SCHEMA
-    const out: ILlmFunction<any>["parameters"] = LlmParametersProgrammer.write({
-      model,
+    const out: ILlmSchema.IParameters = LlmParametersProgrammer.write({
       metadata: analyze(false),
       config,
     });
@@ -91,11 +85,6 @@ export namespace LlmParametersTransformer {
           ts.factory.createIdentifier("ILlmSchema"),
           ts.factory.createIdentifier("IParameters"),
         ),
-        arguments: [
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral(model),
-          ),
-        ],
       }),
     );
   };

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

@@ -8,7 +8,7 @@ import { MetadataFactory } from "../../../factories/MetadataFactory";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
-import { LlmModelPredicator } from "../../../programmers/llm/LlmModelPredicator";
+import { LlmMetadataFactory } from "../../../programmers/llm/LlmMetadataFactory";
 import { LlmSchemaProgrammer } from "../../../programmers/llm/LlmSchemaProgrammer";
 
 import { ValidationPipe } from "../../../typings/ValidationPipe";
@@ -31,16 +31,10 @@ export namespace LlmSchemaTransformer {
     if (ts.isTypeNode(top) === false) return props.expression;
 
     // GET TYPE
-    const model: ILlmSchema.Model = LlmModelPredicator.getModel({
-      checker: props.context.checker,
-      method: "schema",
-      node: props.expression.typeArguments[1],
-    });
-    const config: Partial<ILlmSchema.IConfig> = LlmModelPredicator.getConfig({
+    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
       context: props.context,
       method: "schema",
-      model,
-      node: props.expression.typeArguments[2],
+      node: props.expression.typeArguments[1],
     }) as Partial<ILlmSchema.IConfig>;
 
     const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
@@ -57,10 +51,11 @@ export namespace LlmSchemaTransformer {
             escape: true,
             validate:
               validate === true
-                ? LlmSchemaProgrammer.validate({
-                    model,
-                    config,
-                  })
+                ? (metadata: Metadata) =>
+                    LlmSchemaProgrammer.validate({
+                      config,
+                      metadata,
+                    })
                 : undefined,
           },
           collection: new MetadataCollection({
@@ -78,17 +73,13 @@ export namespace LlmSchemaTransformer {
     analyze(true);
 
     // GENERATE LLM SCHEMA
-    const out: LlmSchemaProgrammer.IOutput<any> = LlmSchemaProgrammer.write({
-      model,
+    const out: LlmSchemaProgrammer.IOutput = LlmSchemaProgrammer.write({
       metadata: analyze(false),
       config,
     });
     const schemaTypeNode = props.context.importer.type({
       file: "@samchon/openapi",
       name: "ILlmSchema",
-      arguments: [
-        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(model)),
-      ],
     });
     const literal = ts.factory.createAsExpression(
       LiteralFactory.write(out.schema),
@@ -101,24 +92,10 @@ export namespace LlmSchemaTransformer {
         undefined,
         [
           IdentifierFactory.parameter(
-            "props",
-            ts.factory.createTypeLiteralNode([
-              ts.factory.createPropertySignature(
-                undefined,
-                ts.factory.createIdentifier("$defs"),
-                ts.factory.createToken(ts.SyntaxKind.QuestionToken),
-                ts.factory.createUnionTypeNode([
-                  ts.factory.createTypeReferenceNode("Record", [
-                    ts.factory.createKeywordTypeNode(
-                      ts.SyntaxKind.StringKeyword,
-                    ),
-                    schemaTypeNode,
-                  ]),
-                  ts.factory.createKeywordTypeNode(
-                    ts.SyntaxKind.UndefinedKeyword,
-                  ),
-                ]),
-              ),
+            "$defs",
+            ts.factory.createTypeReferenceNode("Record", [
+              ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+              schemaTypeNode,
             ]),
             undefined,
           ),
@@ -127,35 +104,22 @@ export namespace LlmSchemaTransformer {
         undefined,
         ts.factory.createBlock(
           [
-            ts.factory.createIfStatement(
-              ts.factory.createStrictInequality(
-                ts.factory.createIdentifier("undefined"),
-                IdentifierFactory.access(
-                  ts.factory.createIdentifier("props"),
-                  "$defs",
-                  true,
-                ),
-              ),
-              ts.factory.createExpressionStatement(
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("Object.assign"),
-                  undefined,
-                  [
-                    IdentifierFactory.access(
-                      ts.factory.createIdentifier("props"),
-                      "$defs",
-                    ),
-                    ts.factory.createAsExpression(
-                      LiteralFactory.write(out.$defs),
-                      ts.factory.createTypeReferenceNode("Record", [
-                        ts.factory.createKeywordTypeNode(
-                          ts.SyntaxKind.StringKeyword,
-                        ),
-                        schemaTypeNode,
-                      ]),
-                    ),
-                  ],
-                ),
+            ts.factory.createExpressionStatement(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Object.assign"),
+                undefined,
+                [
+                  ts.factory.createIdentifier("$defs"),
+                  ts.factory.createAsExpression(
+                    LiteralFactory.write(out.$defs),
+                    ts.factory.createTypeReferenceNode("Record", [
+                      ts.factory.createKeywordTypeNode(
+                        ts.SyntaxKind.StringKeyword,
+                      ),
+                      schemaTypeNode,
+                    ]),
+                  ),
+                ],
               ),
             ),
             ts.factory.createReturnStatement(literal),

package/lib/programmers/llm/LlmModelPredicator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LlmModelPredicator.js","sourceRoot":"","sources":["../../../src/programmers/llm/LlmModelPredicator.ts"],"names":[],"mappings":"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"}

package/lib/programmers/llm/LlmModelPredicator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"LlmModelPredicator.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}