typia 7.6.0-dev.20241229 → 7.7.0-dev.20250130

package/src/programmers/llm/LlmApplicationOfValidateProgrammer.ts

@@ -1,6 +1,8 @@
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import ts from "typescript";
 
+import { TypeFactory } from "../../factories/TypeFactory";
+
 import { ILlmApplicationOfValidate } from "../../schemas/llm/ILlmApplicationOfValidate";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataParameter } from "../../schemas/metadata/MetadataParameter";
@@ -55,7 +57,7 @@ export namespace LlmApplicationOfValidateProgrammer {
           modulo: props.modulo,
           className: props.name,
           name: func.name,
-          parameter: parameters[func.name]!,
+          parameter: parameters[func.name] ?? null,
         }),
       })),
     };
@@ -64,10 +66,22 @@ export namespace LlmApplicationOfValidateProgrammer {
   const writeValidadtor = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    parameter: MetadataParameter;
+    parameter: MetadataParameter | null;
     name: string;
     className?: string;
   }): ((props: object) => IValidation<unknown>) => {
+    if (props.parameter === null)
+      return ValidateProgrammer.write({
+        ...props,
+        type: props.context.checker.getTypeFromTypeNode(
+          TypeFactory.keyword("any"),
+        ),
+        config: {
+          equals: false,
+        },
+        name: undefined,
+      }) as any;
+
     const type = props.parameter.tsType;
     if (type === undefined)
       // unreachable

package/src/programmers/llm/LlmApplicationProgrammer.ts

@@ -42,12 +42,12 @@ export namespace LlmApplicationProgrammer {
         else return LlmSchemaProgrammer.validate(props)(metadata);
 
       const output: string[] = [];
-      const valid: boolean =
+      const validity: boolean =
         metadata.size() === 1 &&
         metadata.objects.length === 1 &&
         metadata.isRequired() === true &&
         metadata.nullable === false;
-      if (valid === false)
+      if (validity === false)
         output.push(
           "LLM application's generic arugment must be a class/interface type.",
         );
@@ -60,23 +60,40 @@ export namespace LlmApplicationProgrammer {
           );
         let least: boolean = false;
         for (const p of object.properties) {
+          const name: string = JSON.stringify(p.key.getSoleLiteral()!);
           const value: Metadata = p.value;
           if (value.functions.length) {
             least ||= true;
-            if (valid === false) {
+            if (validity === false) {
               if (value.functions.length !== 1 || value.size() !== 1)
                 output.push(
-                  "LLM application's function type does not allow union type.",
+                  `LLM application's function (${name}) type does not allow union type.`,
                 );
               if (value.isRequired() === false)
                 output.push(
-                  "LLM application's function type must be required.",
+                  `LLM application's function (${name}) type must be required.`,
                 );
               if (value.nullable === true)
                 output.push(
-                  "LLM application's function type must not be nullable.",
+                  `LLM application's function (${name}) type must not be nullable.`,
                 );
             }
+
+            const description: string | undefined = concatDescription(
+              JsonApplicationProgrammer.writeDescription({
+                description:
+                  p.description ??
+                  p.jsDocTags.find((tag) => tag.name === "description")
+                    ?.text?.[0]?.text ??
+                  null,
+                jsDocTags: p.jsDocTags,
+                kind: "summary",
+              }),
+            );
+            if (description !== undefined && description.length > 1_024)
+              output.push(
+                `LLM application's function (${name}) description must not exceed 1,024 characters.`,
+              );
           }
         }
         if (least === false)
@@ -96,10 +113,14 @@ export namespace LlmApplicationProgrammer {
         `${prefix}'s return type must not be union type with undefined.`,
       );
     if (/^[0-9]/.test(name[0] ?? "") === true)
-      output.push(`name must not start with a number.`);
+      output.push(`${prefix} name must not start with a number.`);
     if (/^[a-zA-Z0-9_-]+$/.test(name) === false)
-      output.push(`name must be alphanumeric with underscore or hypen.`);
-    if (func.parameters.length !== 1)
+      output.push(
+        `${prefix} name must be alphanumeric with underscore or hypen.`,
+      );
+    if (name.length > 64)
+      output.push(`${prefix} name must not exceed 64 characters.`);
+    if (func.parameters.length !== 0 && func.parameters.length !== 1)
       output.push(`${prefix} must have a single parameter.`);
     if (func.parameters.length !== 0) {
       const type: Metadata = func.parameters[0]!.type;
@@ -233,9 +254,12 @@ export namespace LlmApplicationProgrammer {
     errors: string[];
     accessor: string;
   }): ILlmSchema.ModelParameters[Model] | null => {
-    const schema = props.function.parameters[0]?.schema;
-    if (!schema) return null;
-
+    const schema = props.function.parameters[0]?.schema ?? {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+      required: [],
+    };
     const result: IResult<
       ILlmSchema.ModelParameters[Model],
       IOpenApiSchemaError
@@ -286,4 +310,18 @@ export namespace LlmApplicationProgrammer {
     }
     return result.value;
   };
+
+  const concatDescription = (p: {
+    summary?: string | undefined;
+    description?: string | undefined;
+  }): string | undefined => {
+    if (!p.summary?.length || !p.description?.length)
+      return p.summary ?? p.description;
+    const summary: string = p.summary.endsWith(".")
+      ? p.summary.slice(0, -1)
+      : p.summary;
+    return p.description.startsWith(summary)
+      ? p.description
+      : summary + ".\n\n" + p.description;
+  };
 }

package/src/protobuf.ts

@@ -73,7 +73,7 @@ export function message(): never {
  *
  * For reference, as Protocol Buffer handles binary data directly, there's no way
  * when `input` binary data was not encoded from the `T` typed value. In that case,
- * unexpected behavior or internal error would be occured. Therefore, I recommend you
+ * unexpected behavior or internal error would be occurred. Therefore, I recommend you
  * to encode binary data of Protocol Buffer from type safe encode functions like below.
  * Use {@link encode} function only when you can ensure it.
  *
@@ -103,7 +103,7 @@ export function decode(input: Uint8Array): never;
  *
  * For reference, as Protocol Buffer handles binary data directly, there's no way
  * when `input` binary data was not encoded from the `T` typed value. In that case,
- * unexpected behavior or internal error would be occured. Therefore, I recommend you
+ * unexpected behavior or internal error would be occurred. Therefore, I recommend you
  * to encode binary data of Protocol Buffer from type safe encode functions like below.
  * Use {@link encode} function only when you can ensure it.
  *
@@ -354,7 +354,7 @@ export function validateDecode(): never {
  * For reference, this `typia.protobuf.encode()` does not validate the `input` value.
  * It just believes that the `input` value is valid and converts it to a binary data
  * directly. Therefore, if you can't ensure the `input` value type, it would better to
- * call one of below functions intead.
+ * call one of below functions instead.
  *
  *  - {@link assertEncode}
  *  - {@link isEncode}
@@ -394,7 +394,7 @@ export function encode(): never {
  * Protocol Buffer binary data would be returned.
  *
  * If you can trust `input` value, or want to perform other type of validation, use
- * below functions intead.
+ * below functions instead.
  *
  *  - {@link encode}
  *  - {@link isEncode}
@@ -431,7 +431,7 @@ export function assertEncode<T>(
  * Protocol Buffer binary data would be returned.
  *
  * If you can trust `input` value, or want to perform other type of validation, use
- * below functions intead.
+ * below functions instead.
  *
  *  - {@link encode}
  *  - {@link isEncode}
@@ -475,7 +475,7 @@ export function assertEncode(): never {
  * Buffer binary data would be returned.
  *
  * If you can trust `input` value, or want to perform other type of validation, use
- * below functions intead.
+ * below functions instead.
  *
  *  - {@link encode}
  *  - {@link assertEncode}
@@ -508,7 +508,7 @@ export function isEncode<T>(input: T): Uint8Array | null;
  * Buffer binary data would be returned.
  *
  * If you can trust `input` value, or want to perform other type of validation, use
- * below functions intead.
+ * below functions instead.
  *
  *  - {@link encode}
  *  - {@link assertEncode}
@@ -549,7 +549,7 @@ export function isEncode(): never {
  * `data` property of the output {@link IValidation.ISuccess} instance.
  *
  * If you can trust `input` value, or want to perform other type of validation, use
- * below functions intead.
+ * below functions instead.
  *
  *  - {@link encode}
  *  - {@link assertEncode}
@@ -583,7 +583,7 @@ export function validateEncode<T>(input: T): IValidation<Uint8Array>;
  * `data` property of the output {@link IValidation.ISuccess} instance.
  *
  * If you can trust `input` value, or want to perform other type of validation, use
- * below functions intead.
+ * below functions instead.
  *
  *  - {@link encode}
  *  - {@link assertEncode}

package/src/schemas/metadata/IJsDocTagInfo.ts

@@ -1,10 +1,10 @@
-export interface IJsDocTagInfo {
-  name: string;
-  text?: IJsDocTagInfo.IText[];
-}
-export namespace IJsDocTagInfo {
-  export interface IText {
-    text: string;
-    kind: string;
-  }
-}
+export interface IJsDocTagInfo {
+  name: string;
+  text?: IJsDocTagInfo.IText[];
+}
+export namespace IJsDocTagInfo {
+  export interface IText {
+    text: string;
+    kind: string;
+  }
+}

package/src/schemas/metadata/IMetadataArrayType.ts

@@ -1,10 +1,10 @@
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataArrayType {
-  name: string;
-  value: IMetadata;
-
-  nullables: boolean[];
-  recursive: boolean;
-  index: number | null;
-}
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataArrayType {
+  name: string;
+  value: IMetadata;
+
+  nullables: boolean[];
+  recursive: boolean;
+  index: number | null;
+}

package/src/schemas/metadata/IMetadataAtomic.ts

@@ -1,6 +1,6 @@
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataAtomic {
-  type: "boolean" | "bigint" | "number" | "string";
-  tags: IMetadataTypeTag[][];
-}
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataAtomic {
+  type: "boolean" | "bigint" | "number" | "string";
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataConstant.ts

@@ -1,18 +1,18 @@
-import { Atomic } from "../../typings/Atomic";
-
-import { IMetadataConstantValue } from "./IMetadataConstantValue";
-
-export type IMetadataConstant =
-  | IMetadataConstant.IBase<"boolean", boolean>
-  | IMetadataConstant.IBase<"number", number>
-  | IMetadataConstant.IBase<"string", string>
-  | IMetadataConstant.IBase<"bigint", string>;
-export namespace IMetadataConstant {
-  export interface IBase<
-    Type extends Atomic.Literal,
-    Value extends Atomic.Type,
-  > {
-    type: Type;
-    values: IMetadataConstantValue<Value>[];
-  }
-}
+import { Atomic } from "../../typings/Atomic";
+
+import { IMetadataConstantValue } from "./IMetadataConstantValue";
+
+export type IMetadataConstant =
+  | IMetadataConstant.IBase<"boolean", boolean>
+  | IMetadataConstant.IBase<"number", number>
+  | IMetadataConstant.IBase<"string", string>
+  | IMetadataConstant.IBase<"bigint", string>;
+export namespace IMetadataConstant {
+  export interface IBase<
+    Type extends Atomic.Literal,
+    Value extends Atomic.Type,
+  > {
+    type: Type;
+    values: IMetadataConstantValue<Value>[];
+  }
+}

package/src/schemas/metadata/IMetadataEscaped.ts

@@ -1,6 +1,6 @@
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataEscaped {
-  original: IMetadata;
-  returns: IMetadata;
-}
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataEscaped {
+  original: IMetadata;
+  returns: IMetadata;
+}

package/src/schemas/metadata/IMetadataFunction.ts

@@ -1,8 +1,8 @@
-import { IMetadata } from "./IMetadata";
-import { IMetadataParameter } from "./IMetadataParameter";
-
-export interface IMetadataFunction {
-  parameters: IMetadataParameter[];
-  output: IMetadata;
-  async: boolean;
-}
+import { IMetadata } from "./IMetadata";
+import { IMetadataParameter } from "./IMetadataParameter";
+
+export interface IMetadataFunction {
+  parameters: IMetadataParameter[];
+  output: IMetadata;
+  async: boolean;
+}

package/src/schemas/metadata/IMetadataParameter.ts

@@ -1,9 +1,9 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataParameter {
-  name: string;
-  type: IMetadata;
-  description: string | null;
-  jsDocTags: IJsDocTagInfo[];
-}
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataParameter {
+  name: string;
+  type: IMetadata;
+  description: string | null;
+  jsDocTags: IJsDocTagInfo[];
+}

package/src/schemas/metadata/IMetadataProperty.ts

@@ -1,9 +1,9 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataProperty {
-  key: IMetadata;
-  value: IMetadata;
-  description: string | null;
-  jsDocTags: IJsDocTagInfo[];
-}
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataProperty {
+  key: IMetadata;
+  value: IMetadata;
+  description: string | null;
+  jsDocTags: IJsDocTagInfo[];
+}

package/src/schemas/metadata/IMetadataTupleType.ts

@@ -1,10 +1,10 @@
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataTupleType {
-  name: string;
-  elements: IMetadata[];
-
-  index: number | null;
-  recursive: boolean;
-  nullables: boolean[];
-}
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataTupleType {
+  name: string;
+  elements: IMetadata[];
+
+  index: number | null;
+  recursive: boolean;
+  nullables: boolean[];
+}

package/src/schemas/metadata/MetadataArrayType.ts

@@ -1,57 +1,57 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataArrayType } from "./IMetadataArrayType";
-import { Metadata } from "./Metadata";
-
-export class MetadataArrayType {
-  public readonly name: string;
-  public readonly value: Metadata;
-  public readonly nullables: boolean[];
-  public readonly recursive: boolean;
-  public readonly index: number | null;
-
-  /**
-   * @hidden
-   */
-  private constructor(props: ClassProperties<MetadataArrayType>) {
-    this.name = props.name;
-    this.value = props.value;
-    this.index = props.index;
-    this.recursive = props.recursive;
-    this.nullables = props.nullables;
-  }
-
-  /**
-   * @internal
-   */
-  public static _From_without_value(
-    props: Omit<IMetadataArrayType, "value">,
-  ): MetadataArrayType {
-    return MetadataArrayType.create({
-      name: props.name,
-      value: null!,
-      index: props.index,
-      recursive: props.recursive,
-      nullables: props.nullables,
-    });
-  }
-
-  /**
-   * @internal
-   */
-  public static create(
-    props: ClassProperties<MetadataArrayType>,
-  ): MetadataArrayType {
-    return new MetadataArrayType(props);
-  }
-
-  public toJSON(): IMetadataArrayType {
-    return {
-      name: this.name,
-      value: this.value.toJSON(),
-      nullables: this.nullables,
-      recursive: this.recursive,
-      index: this.index,
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { Metadata } from "./Metadata";
+
+export class MetadataArrayType {
+  public readonly name: string;
+  public readonly value: Metadata;
+  public readonly nullables: boolean[];
+  public readonly recursive: boolean;
+  public readonly index: number | null;
+
+  /**
+   * @hidden
+   */
+  private constructor(props: ClassProperties<MetadataArrayType>) {
+    this.name = props.name;
+    this.value = props.value;
+    this.index = props.index;
+    this.recursive = props.recursive;
+    this.nullables = props.nullables;
+  }
+
+  /**
+   * @internal
+   */
+  public static _From_without_value(
+    props: Omit<IMetadataArrayType, "value">,
+  ): MetadataArrayType {
+    return MetadataArrayType.create({
+      name: props.name,
+      value: null!,
+      index: props.index,
+      recursive: props.recursive,
+      nullables: props.nullables,
+    });
+  }
+
+  /**
+   * @internal
+   */
+  public static create(
+    props: ClassProperties<MetadataArrayType>,
+  ): MetadataArrayType {
+    return new MetadataArrayType(props);
+  }
+
+  public toJSON(): IMetadataArrayType {
+    return {
+      name: this.name,
+      value: this.value.toJSON(),
+      nullables: this.nullables,
+      recursive: this.recursive,
+      index: this.index,
+    };
+  }
+}

package/src/schemas/metadata/MetadataConstant.ts

@@ -1,34 +1,34 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataConstant } from "./IMetadataConstant";
-import { MetadataConstantValue } from "./MetadataConstantValue";
-
-export class MetadataConstant {
-  public readonly type: "boolean" | "bigint" | "number" | "string";
-  public readonly values: MetadataConstantValue[];
-
-  private constructor(props: ClassProperties<MetadataConstant>) {
-    this.type = props.type;
-    this.values = props.values.map(MetadataConstantValue.create);
-  }
-
-  public static create(
-    props: ClassProperties<MetadataConstant>,
-  ): MetadataConstant {
-    return new MetadataConstant(props);
-  }
-
-  public static from(json: IMetadataConstant): MetadataConstant {
-    return MetadataConstant.create({
-      type: json.type,
-      values: json.values.map(MetadataConstantValue.from),
-    });
-  }
-
-  public toJSON(): IMetadataConstant {
-    return {
-      type: this.type,
-      values: this.values.map((value) => value.toJSON()),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataConstant } from "./IMetadataConstant";
+import { MetadataConstantValue } from "./MetadataConstantValue";
+
+export class MetadataConstant {
+  public readonly type: "boolean" | "bigint" | "number" | "string";
+  public readonly values: MetadataConstantValue[];
+
+  private constructor(props: ClassProperties<MetadataConstant>) {
+    this.type = props.type;
+    this.values = props.values.map(MetadataConstantValue.create);
+  }
+
+  public static create(
+    props: ClassProperties<MetadataConstant>,
+  ): MetadataConstant {
+    return new MetadataConstant(props);
+  }
+
+  public static from(json: IMetadataConstant): MetadataConstant {
+    return MetadataConstant.create({
+      type: json.type,
+      values: json.values.map(MetadataConstantValue.from),
+    });
+  }
+
+  public toJSON(): IMetadataConstant {
+    return {
+      type: this.type,
+      values: this.values.map((value) => value.toJSON()),
+    };
+  }
+}