typia 7.0.1 → 7.0.2-dev.20241204

package/src/programmers/llm/LlmModelPredicator.ts

@@ -1,127 +1,127 @@
-import { ILlmSchema } from "@samchon/openapi";
-import { LlmSchemaComposer } from "@samchon/openapi/lib/composers/LlmSchemaComposer";
-import ts from "typescript";
-
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { MetadataFactory } from "../../factories/MetadataFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { ValidationPipe } from "../../typings/ValidationPipe";
-
-export namespace LlmModelPredicator {
-  export const getConfig = (props: {
-    context: ITypiaContext;
-    method: string;
-    model: ILlmSchema.Model;
-    node: ts.TypeNode | undefined;
-  }): Partial<ILlmSchema.ModelConfig[ILlmSchema.Model]> | undefined => {
-    if (props.node === undefined) return undefined;
-    const type: ts.Type = props.context.checker.getTypeFromTypeNode(props.node);
-    const collection: MetadataCollection = new MetadataCollection();
-    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-      MetadataFactory.analyze({
-        checker: props.context.checker,
-        transformer: props.context.transformer,
-        options: {
-          escape: false,
-          constant: true,
-          absorb: false,
-          functional: false,
-        },
-        collection,
-        type,
-      });
-    if (result.success === false)
-      throw new TransformerError({
-        code: `typia.llm.${props.method}`,
-        message: `Failed to analyze generic argument "Config".`,
-      });
-
-    const meta: Metadata = result.data;
-    if (
-      meta.size() !== 1 ||
-      meta.objects.length !== 1 ||
-      meta.nullable === true ||
-      meta.isRequired() === false
-    )
-      throw new TransformerError({
-        code: `typia.llm.${props.method}`,
-        message: `Invalid generic argument "Config". It must be a literal object type.`,
-      });
-
-    const obj: MetadataObject = meta.objects[0]!;
-    if (obj.type.properties.some((p) => p.key.isSoleLiteral() === false))
-      throw new TransformerError({
-        code: `typia.llm.${props.method}`,
-        message: `Invalid generic argument "Config". It must be a literal object type. Do not allow dynamic properties.`,
-      });
-    else if (
-      obj.type.properties.some(
-        (p) =>
-          p.value.size() !== 1 ||
-          p.value.constants.length !== 1 ||
-          p.value.nullable === true ||
-          p.value.isRequired() === false,
-      )
-    )
-      throw new TransformerError({
-        code: `typia.llm.${props.method}`,
-        message: `Invalid generic argument "Config". It must be a literal object type. Do not allow variable type.`,
-      });
-    const config: Partial<ILlmSchema.ModelConfig[ILlmSchema.Model]> = {};
-    for (const prop of obj.type.properties) {
-      const key: string = prop.key.getSoleLiteral()!;
-      const value: boolean | bigint | number | string =
-        prop.value.constants[0]!.values[0]!.value;
-      if (typeof value === "bigint")
-        throw new TransformerError({
-          code: `typia.llm.${props.method}`,
-          message: `Invalid generic argument "Config". It must be a literal object type. Do not allow bigint.`,
-        });
-      (config as any)[key] = value;
-    }
-    return config;
-  };
-
-  export const getModel = (props: {
-    checker: ts.TypeChecker;
-    method: string;
-    node: ts.TypeNode | undefined;
-  }): ILlmSchema.Model => {
-    if (props.node === undefined)
-      throw new TransformerError({
-        code: `typia.llm.${props.method}`,
-        message: `generic argument "Model" must be specified.`,
-      });
-
-    // CHECK LITERAL TYPE
-    const type: ts.Type = props.checker.getTypeFromTypeNode(props.node);
-    if (
-      !type.isLiteral() &&
-      (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
-    )
-      throw new TransformerError({
-        code: `typia.llm.${props.method}`,
-        message: `generic argument "Model" must be constant.`,
-      });
-
-    // GET VALUE AND VALIDATE IT
-    const value = type.isLiteral()
-      ? type.value
-      : props.checker.typeToString(type);
-    if (
-      typeof value !== "string" ||
-      LlmSchemaComposer.defaultConfig(value as "3.0") === undefined
-    )
-      throw new TransformerError({
-        code: "typia.llm.schema",
-        message: `invalid value on generic argument "Model".`,
-      });
-    return value as ILlmSchema.Model;
-  };
-}
+import { ILlmSchema } from "@samchon/openapi";
+import { LlmSchemaComposer } from "@samchon/openapi/lib/composers/LlmSchemaComposer";
+import ts from "typescript";
+
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { MetadataFactory } from "../../factories/MetadataFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { ValidationPipe } from "../../typings/ValidationPipe";
+
+export namespace LlmModelPredicator {
+  export const getConfig = (props: {
+    context: ITypiaContext;
+    method: string;
+    model: ILlmSchema.Model;
+    node: ts.TypeNode | undefined;
+  }): Partial<ILlmSchema.ModelConfig[ILlmSchema.Model]> | undefined => {
+    if (props.node === undefined) return undefined;
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(props.node);
+    const collection: MetadataCollection = new MetadataCollection();
+    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+      MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          escape: false,
+          constant: true,
+          absorb: false,
+          functional: false,
+        },
+        collection,
+        type,
+      });
+    if (result.success === false)
+      throw new TransformerError({
+        code: `typia.llm.${props.method}`,
+        message: `Failed to analyze generic argument "Config".`,
+      });
+
+    const meta: Metadata = result.data;
+    if (
+      meta.size() !== 1 ||
+      meta.objects.length !== 1 ||
+      meta.nullable === true ||
+      meta.isRequired() === false
+    )
+      throw new TransformerError({
+        code: `typia.llm.${props.method}`,
+        message: `Invalid generic argument "Config". It must be a literal object type.`,
+      });
+
+    const obj: MetadataObject = meta.objects[0]!;
+    if (obj.type.properties.some((p) => p.key.isSoleLiteral() === false))
+      throw new TransformerError({
+        code: `typia.llm.${props.method}`,
+        message: `Invalid generic argument "Config". It must be a literal object type. Do not allow dynamic properties.`,
+      });
+    else if (
+      obj.type.properties.some(
+        (p) =>
+          p.value.size() !== 1 ||
+          p.value.constants.length !== 1 ||
+          p.value.nullable === true ||
+          p.value.isRequired() === false,
+      )
+    )
+      throw new TransformerError({
+        code: `typia.llm.${props.method}`,
+        message: `Invalid generic argument "Config". It must be a literal object type. Do not allow variable type.`,
+      });
+    const config: Partial<ILlmSchema.ModelConfig[ILlmSchema.Model]> = {};
+    for (const prop of obj.type.properties) {
+      const key: string = prop.key.getSoleLiteral()!;
+      const value: boolean | bigint | number | string =
+        prop.value.constants[0]!.values[0]!.value;
+      if (typeof value === "bigint")
+        throw new TransformerError({
+          code: `typia.llm.${props.method}`,
+          message: `Invalid generic argument "Config". It must be a literal object type. Do not allow bigint.`,
+        });
+      (config as any)[key] = value;
+    }
+    return config;
+  };
+
+  export const getModel = (props: {
+    checker: ts.TypeChecker;
+    method: string;
+    node: ts.TypeNode | undefined;
+  }): ILlmSchema.Model => {
+    if (props.node === undefined)
+      throw new TransformerError({
+        code: `typia.llm.${props.method}`,
+        message: `generic argument "Model" must be specified.`,
+      });
+
+    // CHECK LITERAL TYPE
+    const type: ts.Type = props.checker.getTypeFromTypeNode(props.node);
+    if (
+      !type.isLiteral() &&
+      (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+    )
+      throw new TransformerError({
+        code: `typia.llm.${props.method}`,
+        message: `generic argument "Model" must be constant.`,
+      });
+
+    // GET VALUE AND VALIDATE IT
+    const value = type.isLiteral()
+      ? type.value
+      : props.checker.typeToString(type);
+    if (
+      typeof value !== "string" ||
+      LlmSchemaComposer.defaultConfig(value as "3.0") === undefined
+    )
+      throw new TransformerError({
+        code: "typia.llm.schema",
+        message: `invalid value on generic argument "Model".`,
+      });
+    return value as ILlmSchema.Model;
+  };
+}

package/src/programmers/llm/LlmParametersProgrammer.ts

@@ -1,90 +1,90 @@
-import {
-  ILlmSchema,
-  IOpenApiSchemaError,
-  IResult,
-  OpenApi,
-  OpenApiTypeChecker,
-} from "@samchon/openapi";
-import { LlmSchemaComposer } from "@samchon/openapi/lib/composers/LlmSchemaComposer";
-
-import { MetadataFactory } from "../../factories/MetadataFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { TransformerError } from "../../transformers/TransformerError";
-
-import { IJsonSchemaCollection } from "../../module";
-import { JsonSchemasProgrammer } from "../json/JsonSchemasProgrammer";
-import { LlmSchemaProgrammer } from "./LlmSchemaProgrammer";
-
-export namespace LlmParametersProgrammer {
-  export const write = <Model extends ILlmSchema.Model>(props: {
-    model: Model;
-    metadata: Metadata;
-    config?: Partial<ILlmSchema.ModelConfig[Model]>;
-  }): ILlmSchema.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 result: IResult<
-      ILlmSchema.ModelParameters[Model],
-      IOpenApiSchemaError
-    > = LlmSchemaComposer.parameters(props.model)({
-      config: {
-        ...LlmSchemaComposer.defaultConfig(props.model),
-        ...props.config,
-      } as any,
-      components: collection.components,
-      schema,
-    }) as IResult<ILlmSchema.ModelParameters[Model], IOpenApiSchemaError>;
-    if (result.success === false)
-      throw new TransformerError({
-        code: "typia.llm.parameters",
-        message:
-          "failed to convert JSON schema to LLM schema.\n\n" +
-          result.error.reasons
-            .map((r) => `  - ${r.accessor}: ${r.message}`)
-            .join("\n"),
-      });
-    return result.value;
-  };
-
-  export const validate =
-    (model: ILlmSchema.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.objects[0]!.type.properties.some(
-              (p) => p.key.isSoleLiteral() === false,
-            )
-          )
-            output.push("LLM parameters must not have dynamic keys.");
-          if (metadata.nullable)
-            output.push("LLM parameters must be a non-nullable object type.");
-          if (metadata.isRequired() === false)
-            output.push("LLM parameters must be a non-undefined object type.");
-        }
-      }
-      output.push(...LlmSchemaProgrammer.validate(model)(metadata));
-      return output;
-    };
-}
+import {
+  ILlmSchema,
+  IOpenApiSchemaError,
+  IResult,
+  OpenApi,
+  OpenApiTypeChecker,
+} from "@samchon/openapi";
+import { LlmSchemaComposer } from "@samchon/openapi/lib/composers/LlmSchemaComposer";
+
+import { MetadataFactory } from "../../factories/MetadataFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { TransformerError } from "../../transformers/TransformerError";
+
+import { IJsonSchemaCollection } from "../../module";
+import { JsonSchemasProgrammer } from "../json/JsonSchemasProgrammer";
+import { LlmSchemaProgrammer } from "./LlmSchemaProgrammer";
+
+export namespace LlmParametersProgrammer {
+  export const write = <Model extends ILlmSchema.Model>(props: {
+    model: Model;
+    metadata: Metadata;
+    config?: Partial<ILlmSchema.ModelConfig[Model]>;
+  }): ILlmSchema.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 result: IResult<
+      ILlmSchema.ModelParameters[Model],
+      IOpenApiSchemaError
+    > = LlmSchemaComposer.parameters(props.model)({
+      config: {
+        ...LlmSchemaComposer.defaultConfig(props.model),
+        ...props.config,
+      } as any,
+      components: collection.components,
+      schema,
+    }) as IResult<ILlmSchema.ModelParameters[Model], IOpenApiSchemaError>;
+    if (result.success === false)
+      throw new TransformerError({
+        code: "typia.llm.parameters",
+        message:
+          "failed to convert JSON schema to LLM schema.\n\n" +
+          result.error.reasons
+            .map((r) => `  - ${r.accessor}: ${r.message}`)
+            .join("\n"),
+      });
+    return result.value;
+  };
+
+  export const validate =
+    (model: ILlmSchema.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.objects[0]!.type.properties.some(
+              (p) => p.key.isSoleLiteral() === false,
+            )
+          )
+            output.push("LLM parameters must not have dynamic keys.");
+          if (metadata.nullable)
+            output.push("LLM parameters must be a non-nullable object type.");
+          if (metadata.isRequired() === false)
+            output.push("LLM parameters must be a non-undefined object type.");
+        }
+      }
+      output.push(...LlmSchemaProgrammer.validate(model)(metadata));
+      return output;
+    };
+}