typia 7.0.0-dev.20241023 → 7.0.0-dev.20241111

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

@@ -28,6 +28,19 @@ export namespace LlmApplicationTransformer {
     const top: ts.Node = props.expression.typeArguments[0]!;
     if (ts.isTypeNode(top) === false) return props.expression;
 
+    // GET MODEL
+    const model: ILlmApplication.Model = get_parameter<ILlmApplication.Model>({
+      checker: props.context.checker,
+      name: "Model",
+      is: (value) =>
+        value === "3.1" ||
+        value === "3.0" ||
+        value === "chatgpt" ||
+        value === "gemini",
+      cast: (value) => value as ILlmApplication.Model,
+      default: () => "3.1",
+    })(props.expression.typeArguments[1]);
+
     // GET TYPE
     const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
     const collection: MetadataCollection = new MetadataCollection({
@@ -42,7 +55,7 @@ export namespace LlmApplicationTransformer {
           constant: true,
           absorb: false,
           functional: true,
-          validate: LlmApplicationProgrammer.validate(),
+          validate: LlmApplicationProgrammer.validate(model),
         },
         collection,
         type,
@@ -54,7 +67,11 @@ export namespace LlmApplicationTransformer {
       });
 
     // GENERATE LLM APPLICATION
-    const schema: ILlmApplication = LlmApplicationProgrammer.write(result.data);
+    const schema: ILlmApplication<ILlmApplication.Model> =
+      LlmApplicationProgrammer.write({
+        model,
+        metadata: result.data,
+      });
     const literal: ts.Expression = LiteralFactory.write(schema);
     if (!props.expression.arguments?.[0]) return literal;
 
@@ -83,4 +100,38 @@ export namespace LlmApplicationTransformer {
       ),
     );
   };
+
+  const get_parameter =
+    <Value>(props: {
+      checker: ts.TypeChecker;
+      name: string;
+      is: (value: string) => boolean;
+      cast: (value: string) => Value;
+      default: () => Value;
+    }) =>
+    (node: ts.TypeNode | undefined): Value => {
+      if (!node) return props.default();
+
+      // CHECK LITERAL TYPE
+      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
+      if (
+        !type.isLiteral() &&
+        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+      )
+        throw new TransformerError({
+          code: "typia.llm.application",
+          message: `generic argument "${props.name}" must be constant.`,
+        });
+
+      // GET VALUE AND VALIDATE IT
+      const value = type.isLiteral()
+        ? type.value
+        : props.checker.typeToString(type);
+      if (typeof value !== "string" || props.is(value) === false)
+        throw new TransformerError({
+          code: "typia.llm.application",
+          message: `invalid value on generic argument "${props.name}".`,
+        });
+      return props.cast(value);
+    };
 }

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

@@ -1,4 +1,4 @@
-import { ILlmSchema } from "@samchon/openapi";
+import { ILlmApplication } from "@samchon/openapi";
 import ts from "typescript";
 
 import { LiteralFactory } from "../../../factories/LiteralFactory";
@@ -28,6 +28,19 @@ export namespace LlmSchemaTransformer {
     const top: ts.Node = props.expression.typeArguments[0]!;
     if (ts.isTypeNode(top) === false) return props.expression;
 
+    // GET MODEL
+    const model: ILlmApplication.Model = get_parameter<ILlmApplication.Model>({
+      checker: props.context.checker,
+      name: "Model",
+      is: (value) =>
+        value === "3.1" ||
+        value === "3.0" ||
+        value === "chatgpt" ||
+        value === "gemini",
+      cast: (value) => value as ILlmApplication.Model,
+      default: () => "3.1",
+    })(props.expression.typeArguments[1]);
+
     // GET TYPE
     const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
     const collection: MetadataCollection = new MetadataCollection({
@@ -41,7 +54,7 @@ export namespace LlmSchemaTransformer {
           escape: true,
           constant: true,
           absorb: false,
-          validate: LlmSchemaProgrammer.validate,
+          validate: LlmSchemaProgrammer.validate(model),
         },
         collection,
         type,
@@ -53,7 +66,45 @@ export namespace LlmSchemaTransformer {
       });
 
     // GENERATE LLM SCHEMA
-    const schema: ILlmSchema = LlmSchemaProgrammer.write(result.data);
+    const schema: ILlmApplication.ModelSchema[ILlmApplication.Model] =
+      LlmSchemaProgrammer.write({
+        model,
+        metadata: result.data,
+      });
     return LiteralFactory.write(schema);
   };
+
+  const get_parameter =
+    <Value>(props: {
+      checker: ts.TypeChecker;
+      name: string;
+      is: (value: string) => boolean;
+      cast: (value: string) => Value;
+      default: () => Value;
+    }) =>
+    (node: ts.TypeNode | undefined): Value => {
+      if (!node) return props.default();
+
+      // CHECK LITERAL TYPE
+      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
+      if (
+        !type.isLiteral() &&
+        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+      )
+        throw new TransformerError({
+          code: "typia.llm.schema",
+          message: `generic argument "${props.name}" must be constant.`,
+        });
+
+      // GET VALUE AND VALIDATE IT
+      const value = type.isLiteral()
+        ? type.value
+        : props.checker.typeToString(type);
+      if (typeof value !== "string" || props.is(value) === false)
+        throw new TransformerError({
+          code: "typia.llm.schema",
+          message: `invalid value on generic argument "${props.name}".`,
+        });
+      return props.cast(value);
+    };
 }