typia 7.0.0-dev.20241122 → 7.0.0-dev.20241124

package/src/programmers/llm/LlmParametersProgrammer.ts

@@ -0,0 +1,67 @@
+import { ILlmApplication, OpenApi, OpenApiTypeChecker } from "@samchon/openapi";
+import { LlmSchemaConverter } from "@samchon/openapi/lib/converters/LlmSchemaConverter";
+
+import { MetadataFactory } from "../../factories/MetadataFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IJsonSchemaCollection } from "../../module";
+import { JsonSchemasProgrammer } from "../json/JsonSchemasProgrammer";
+import { LlmSchemaProgrammer } from "./LlmSchemaProgrammer";
+
+export namespace LlmParametersProgrammer {
+  export const write = <Model extends ILlmApplication.Model>(props: {
+    model: Model;
+    metadata: Metadata;
+  }): ILlmApplication.ModelParameters[Model] => {
+    const collection: IJsonSchemaCollection<"3.1"> =
+      JsonSchemasProgrammer.write({
+        version: "3.1",
+        metadatas: [props.metadata],
+      });
+    const schema: OpenApi.IJsonSchema.IObject = (() => {
+      const schema: OpenApi.IJsonSchema = collection.schemas[0]!;
+      if (OpenApiTypeChecker.isObject(schema)) return schema;
+      else if (OpenApiTypeChecker.isReference(schema)) {
+        const last =
+          collection.components.schemas?.[schema.$ref.split("/").pop()!];
+        if (last && OpenApiTypeChecker.isObject(last)) return last;
+      }
+      throw new Error("Unreachable code. Failed to find the object schema.");
+    })();
+
+    const parameters: ILlmApplication.ModelParameters[Model] | null =
+      LlmSchemaConverter.parameters(props.model)({
+        config: {
+          recursive: 3,
+          reference: false,
+          constraint: false,
+        },
+        components: collection.components,
+        schema,
+      }) as ILlmApplication.ModelParameters[Model] | null;
+    if (parameters === null)
+      throw new Error("Failed to convert JSON schema to LLM schema.");
+    return parameters;
+  };
+
+  export const validate =
+    (model: ILlmApplication.Model) =>
+    (metadata: Metadata, explore: MetadataFactory.IExplore): string[] => {
+      const output: string[] = [];
+      if (explore.top === true) {
+        if (metadata.objects.length === 0)
+          output.push("LLM parameters must be an objec type.");
+        else if (metadata.objects.length !== 1 || metadata.size() > 1)
+          output.push("LLM parameters must be a single object type.");
+        else {
+          if (metadata.nullable)
+            output.push("LLM parameters must be a non-nullable object type.");
+          else if (metadata.isRequired() === false)
+            output.push("LLM parameters must be a non-undefined object type.");
+        }
+      }
+      output.push(...LlmSchemaProgrammer.validate(model)(metadata));
+      return output;
+    };
+}

package/src/programmers/llm/LlmSchemaProgrammer.ts

@@ -1,13 +1,5 @@
-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 { ILlmApplication } from "@samchon/openapi";
+import { LlmSchemaConverter } from "@samchon/openapi/lib/converters/LlmSchemaConverter";
 
 import { IJsonSchemaCollection } from "../../schemas/json/IJsonSchemaCollection";
 import { Metadata } from "../../schemas/metadata/Metadata";
@@ -24,8 +16,9 @@ export namespace LlmSchemaProgrammer {
   export interface IOutput<Model extends ILlmApplication.Model> {
     model: Model;
     schema: ILlmApplication.ModelSchema[Model];
-    $defs: Record<string, IChatGptSchema>;
+    $defs: Record<string, ILlmApplication.ModelSchema[Model]>;
   }
+
   export const write = <Model extends ILlmApplication.Model>(props: {
     model: Model;
     metadata: Metadata;
@@ -36,20 +29,18 @@ export namespace LlmSchemaProgrammer {
         metadatas: [props.metadata],
       });
 
-    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;
+    const $defs: Record<string, ILlmApplication.ModelSchema[Model]> = {};
+    const schema: ILlmApplication.ModelSchema[Model] | null =
+      LlmSchemaConverter.schema(props.model)({
+        config: {
+          recursive: 3,
+          reference: false,
+          constraint: false,
+        },
+        components: collection.components,
+        schema: collection.schemas[0]!,
+        $defs: $defs as any,
+      }) as ILlmApplication.ModelSchema[Model] | null;
     if (schema === null)
       throw new Error("Failed to convert JSON schema to LLM schema.");
     return {
@@ -68,6 +59,14 @@ export namespace LlmSchemaProgrammer {
         metadata.constants.some((c) => c.type === "bigint")
       )
         output.push("LLM schema does not support bigint type.");
+      if (
+        metadata.objects.some((o) =>
+          o.type.properties.some(
+            (p) => p.key.isSoleLiteral() === false && p.value.size() !== 0,
+          ),
+        )
+      )
+        output.push("LLM schema does not support dynamic property in object.");
       if (
         metadata.tuples.some((t) =>
           t.type.elements.some((e) => e.isRequired() === false),
@@ -130,48 +129,3 @@ 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/transformers/CallExpressionTransformer.ts

@@ -67,6 +67,7 @@ import { JsonStringifyTransformer } from "./features/json/JsonStringifyTransform
 import { JsonValidateParseTransformer } from "./features/json/JsonValidateParseTransformer";
 import { JsonValidateStringifyTransformer } from "./features/json/JsonValidateStringifyTransformer";
 import { LlmApplicationTransformer } from "./features/llm/LlmApplicationTransformer";
+import { LlmParametersTransformer } from "./features/llm/LlmParametersTransformer";
 import { LlmSchemaTransformer } from "./features/llm/LlmSchemaTransformer";
 import { MiscAssertCloneTransformer } from "./features/misc/MiscAssertCloneTransformer";
 import { MiscAssertPruneTransformer } from "./features/misc/MiscAssertPruneTransformer";
@@ -394,6 +395,7 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
   },
   llm: {
     application: () => LlmApplicationTransformer.transform,
+    parameters: () => LlmParametersTransformer.transform,
     schema: () => LlmSchemaTransformer.transform,
   },
   json: {

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

@@ -29,17 +29,18 @@ export namespace LlmApplicationTransformer {
     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]);
+    const model: ILlmApplication.Model =
+      getTemplateArgument<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);
@@ -101,7 +102,7 @@ export namespace LlmApplicationTransformer {
     );
   };
 
-  const get_parameter =
+  const getTemplateArgument =
     <Value>(props: {
       checker: ts.TypeChecker;
       name: string;

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

@@ -0,0 +1,112 @@
+import { ILlmApplication } from "@samchon/openapi";
+import { ILlmFunction } from "@samchon/openapi/lib/structures/ILlmFunction";
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { LlmParametersProgrammer } from "../../../programmers/llm/LlmParametersProgrammer";
+import { LlmSchemaProgrammer } from "../../../programmers/llm/LlmSchemaProgrammer";
+
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace LlmParametersTransformer {
+  export const transform = (
+    props: Omit<ITransformProps, "modulo">,
+  ): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.parameters",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET MODEL
+    const model: ILlmApplication.Model =
+      getTemplateArgument<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({
+      replace: MetadataCollection.replace,
+    });
+    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+      MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          escape: true,
+          constant: true,
+          absorb: false,
+          validate: LlmSchemaProgrammer.validate(model),
+        },
+        collection,
+        type,
+      });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: "typia.llm.parameters",
+        errors: result.errors,
+      });
+
+    // GENERATE LLM SCHEMA
+    const out: ILlmFunction<any>["parameters"] = LlmParametersProgrammer.write({
+      model,
+      metadata: result.data,
+    });
+    return LiteralFactory.write(out);
+  };
+
+  const getTemplateArgument =
+    <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.parameters",
+          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.parameters",
+          message: `invalid value on generic argument "${props.name}".`,
+        });
+      return props.cast(value);
+    };
+}

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

@@ -30,17 +30,18 @@ export namespace LlmSchemaTransformer {
     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]);
+    const model: ILlmApplication.Model =
+      getTemplateArgument<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);
@@ -108,7 +109,7 @@ export namespace LlmSchemaTransformer {
     );
   };
 
-  const get_parameter =
+  const getTemplateArgument =
     <Value>(props: {
       checker: ts.TypeChecker;
       name: string;