typia 13.0.1-dev.20260703.1 → 13.0.2

package/native/core/programmers/llm/LlmApplicationProgrammer.go

@@ -1,526 +1,526 @@
-package llm
-
-import (
-  "fmt"
-  "regexp"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-  nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
-  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
-  nativejson "github.com/samchon/typia/packages/typia/native/core/programmers/json"
-  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-)
-
-type llmApplicationProgrammerNamespace struct{}
-
-var LlmApplicationProgrammer = llmApplicationProgrammerNamespace{}
-
-type LlmApplicationProgrammer_IProps struct {
-  Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    any
-  Name    *string
-  Init    *shimast.Node
-  Config  map[string]any
-}
-
-type LlmApplicationProgrammer_IWriteProps struct {
-  Context        nativecontext.ITypiaContext
-  Modulo         *shimast.Node
-  Metadata       *schemametadata.MetadataSchema
-  Config         map[string]any
-  Name           *string
-  ConfigArgument *shimast.Node
-}
-
-var llmApplicationProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
-func (llmApplicationProgrammerNamespace) Write(props LlmApplicationProgrammer_IWriteProps) *shimast.Node {
-  application := LlmApplicationProgrammer.WriteApplication(struct {
-    Context  nativecontext.ITypiaContext
-    Modulo   *shimast.Node
-    Metadata *schemametadata.MetadataSchema
-    Config   map[string]any
-    Name     *string
-  }{
-    Context:  props.Context,
-    Modulo:   props.Modulo,
-    Metadata: props.Metadata,
-    Config:   props.Config,
-    Name:     props.Name,
-  })
-  f := nativecontext.EmitFactoryOf(llmApplicationProgrammer_factory, props.Context.Emit)
-  var arguments []*shimast.TypeNode
-  if props.Name != nil {
-    arguments = []*shimast.TypeNode{llmProgrammer_type_reference(*props.Name, props.Context.Emit)}
-  }
-  typeNode := llmProgrammer_import_type(props.Context, nativecontext.ImportProgrammer_TypeProps{
-    File:      "typia",
-    Name:      "ILlmApplication.__IPrimitive",
-    Arguments: arguments,
-  })
-  args := []*shimast.Node{
-    f.NewAsExpression(
-      f.NewSatisfiesExpression(nativefactories.LiteralFactory.Write(application, props.Context.Emit), typeNode),
-      typeNode,
-    ),
-  }
-  if props.ConfigArgument != nil {
-    args = append(args, props.ConfigArgument)
-  }
-  var typeArguments *shimast.NodeList
-  if props.Name != nil {
-    typeArguments = f.NewNodeList([]*shimast.Node{llmProgrammer_type_reference(*props.Name, props.Context.Emit)})
-  }
-  return f.NewCallExpression(
-    llmProgrammer_internal(props.Context, "llmApplicationFinalize"),
-    nil,
-    typeArguments,
-    f.NewNodeList(args),
-    shimast.NodeFlagsNone,
-  )
-}
-
-func (llmApplicationProgrammerNamespace) Validate(props struct {
-  Config   map[string]any
-  Metadata *schemametadata.MetadataSchema
-  Explore  nativefactories.MetadataFactory_IExplore
-  Top      *schemametadata.MetadataSchema
-}) []string {
-  if props.Explore.Top == false {
-    if props.Top != nil &&
-      len(props.Top.Objects) != 0 &&
-      props.Explore.Object == props.Top.Objects[0].Type {
-      if _, ok := props.Explore.Property.(string); ok &&
-        props.Metadata.Size() == 1 &&
-        props.Metadata.Nullable == false &&
-        props.Metadata.IsRequired() == true &&
-        len(props.Metadata.Functions) == 1 {
-        return llmApplicationProgrammer_validateFunction(fmt.Sprint(props.Explore.Property), props.Metadata.Functions[0])
-      }
-    }
-    return LlmSchemaProgrammer.Validate(struct {
-      Config   map[string]any
-      Metadata *schemametadata.MetadataSchema
-      Explore  nativefactories.MetadataFactory_IExplore
-    }{Config: props.Config, Metadata: props.Metadata, Explore: props.Explore})
-  }
-
-  output := []string{}
-  isValidType := props.Metadata.Size() == 1 &&
-    len(props.Metadata.Objects) == 1 &&
-    props.Metadata.IsRequired() == true &&
-    props.Metadata.Nullable == false
-  if isValidType == false {
-    output = append(output, "LLM application's generic argument must be a class/interface type.")
-  }
-  var object *schemametadata.MetadataObjectType
-  if len(props.Metadata.Objects) != 0 {
-    object = props.Metadata.Objects[0].Type
-  }
-  if object != nil {
-    for _, property := range object.Properties {
-      if property.Key.IsSoleLiteral() == false {
-        output = append(output, "LLM application does not allow dynamic keys on class/interface type.")
-        break
-      }
-    }
-    least := false
-    for _, property := range object.Properties {
-      rawName := property.Key.GetSoleLiteral()
-      if rawName == nil {
-        continue
-      }
-      value := property.Value
-      if len(value.Functions) == 0 {
-        continue
-      }
-      least = true
-      name := fmt.Sprintf("%q", *rawName)
-      if isValidType == false {
-        if len(value.Functions) != 1 || value.Size() != 1 {
-          output = append(output, "LLM application's function ("+name+") type does not allow union type.")
-        }
-        if value.IsRequired() == false {
-          output = append(output, "LLM application's function ("+name+") type must be required.")
-        }
-        if value.Nullable {
-          output = append(output, "LLM application's function ("+name+") type must not be nullable.")
-        }
-      }
-      prefix := "LLM application's function (" + name + ")"
-      output = append(output, llmApplicationProgrammer_validateName(prefix, *rawName)...)
-      description := llmApplicationProgrammer_propertyDescription(property)
-      if description != nil && len(*description) > 1024 {
-        output = append(output, "LLM application's function ("+name+") description must not exceed 1,024 characters.")
-      }
-    }
-    if least == false {
-      output = append(output, "LLM application's target type must have at least a function type.")
-    }
-  }
-  return output
-}
-
-func (llmApplicationProgrammerNamespace) WriteApplication(props struct {
-  Context  nativecontext.ITypiaContext
-  Modulo   *shimast.Node
-  Metadata *schemametadata.MetadataSchema
-  Config   map[string]any
-  Name     *string
-}) map[string]any {
-  metadata := schemametadata.MetadataSchema_unalias(props.Metadata)
-  functionParameters := map[string]*schemametadata.MetadataParameter{}
-  if len(metadata.Objects) != 0 {
-    for _, property := range metadata.Objects[0].Type.Properties {
-      if property.Key.IsSoleLiteral() == false ||
-        property.Value.Size() != 1 ||
-        property.Value.Nullable ||
-        property.Value.IsRequired() == false {
-        continue
-      }
-      unaliased := schemametadata.MetadataSchema_unalias(property.Value)
-      if len(unaliased.Functions) != 1 || llmApplicationProgrammer_hidden(property.JsDocTags) {
-        continue
-      }
-      key := property.Key.GetSoleLiteral()
-      if key == nil || len(unaliased.Functions[0].Parameters) == 0 {
-        continue
-      }
-      functionParameters[*key] = unaliased.Functions[0].Parameters[0]
-    }
-  }
-  application := nativejson.JsonApplicationProgrammer.WriteApplication(struct {
-    Version  string
-    Metadata *schemametadata.MetadataSchema
-    Filter   func(prop *schemametadata.MetadataProperty) bool
-  }{
-    Version:  "3.1",
-    Metadata: metadata,
-    Filter: func(prop *schemametadata.MetadataProperty) bool {
-      for _, tag := range prop.JsDocTags {
-        if tag.Name == "human" {
-          return false
-        }
-      }
-      return true
-    },
-  })
-  components, _ := application["components"].(*nativeiterate.OpenApi_IComponents)
-  rawFunctions, _ := application["functions"].([]any)
-  functions := []any{}
-  for _, raw := range rawFunctions {
-    fn, ok := raw.(map[string]any)
-    if ok == false {
-      continue
-    }
-    name, _ := fn["name"].(string)
-    written := llmApplicationProgrammer_writeFunction(struct {
-      Context    nativecontext.ITypiaContext
-      Modulo     *shimast.Node
-      Components *nativeiterate.OpenApi_IComponents
-      Function   map[string]any
-      Parameter  *schemametadata.MetadataParameter
-      ClassName  *string
-      Config     map[string]any
-    }{
-      Context:    props.Context,
-      Modulo:     props.Modulo,
-      Components: components,
-      Function:   fn,
-      Parameter:  functionParameters[name],
-      ClassName:  props.Name,
-      Config:     props.Config,
-    })
-    if written != nil {
-      functions = append(functions, written)
-    }
-  }
-  result := map[string]any{"functions": functions}
-  if len(metadata.Objects) != 0 {
-    if object := metadata.Objects[0].Type; object != nil {
-      if description := llmApplicationProgrammer_describe(object.Description, object.JsDocTags); description != nil && len(*description) != 0 {
-        result["description"] = *description
-      }
-    }
-  }
-  return result
-}
-
-func llmApplicationProgrammer_writeFunction(props struct {
-  Context    nativecontext.ITypiaContext
-  Modulo     *shimast.Node
-  Components *nativeiterate.OpenApi_IComponents
-  Function   map[string]any
-  Parameter  *schemametadata.MetadataParameter
-  ClassName  *string
-  Config     map[string]any
-}) map[string]any {
-  name, _ := props.Function["name"].(string)
-  parameters := llmApplicationProgrammer_writeParameters(struct {
-    Context    nativecontext.ITypiaContext
-    Components *nativeiterate.OpenApi_IComponents
-    Function   map[string]any
-    Config     map[string]any
-  }{
-    Context:    props.Context,
-    Components: props.Components,
-    Function:   props.Function,
-    Config:     props.Config,
-  })
-  var output any
-  if raw, ok := props.Function["output"].(map[string]any); ok {
-    if schema, ok := raw["schema"].(nativeiterate.JsonSchema); ok {
-      output = llmApplicationProgrammer_writeOutput(struct {
-        Context    nativecontext.ITypiaContext
-        Components *nativeiterate.OpenApi_IComponents
-        Schema     nativeiterate.JsonSchema
-        Output     map[string]any
-        Config     map[string]any
-      }{Context: props.Context, Components: props.Components, Schema: schema, Output: raw, Config: props.Config})
-    } else if schema, ok := raw["schema"].(map[string]any); ok {
-      output = llmApplicationProgrammer_writeOutput(struct {
-        Context    nativecontext.ITypiaContext
-        Components *nativeiterate.OpenApi_IComponents
-        Schema     nativeiterate.JsonSchema
-        Output     map[string]any
-        Config     map[string]any
-      }{Context: props.Context, Components: props.Components, Schema: nativeiterate.JsonSchema(schema), Output: raw, Config: props.Config})
-    }
-  }
-  result := map[string]any{
-    "name":       name,
-    "parameters": parameters,
-    "validate": llmApplicationProgrammer_writeValidator(struct {
-      Context   nativecontext.ITypiaContext
-      Modulo    *shimast.Node
-      Parameter *schemametadata.MetadataParameter
-      Name      string
-      Equals    bool
-      ClassName *string
-    }{
-      Context:   props.Context,
-      Modulo:    props.Modulo,
-      Parameter: props.Parameter,
-      Name:      name,
-      Equals:    llmApplicationProgrammer_equals(props.Config),
-      ClassName: props.ClassName,
-    }),
-  }
-  if output != nil {
-    result["output"] = output
-  }
-  if summary, ok := props.Function["summary"].(string); ok {
-    if description, ok := props.Function["description"].(string); ok {
-      result["description"] = *llmProgrammer_concat_description(&summary, &description)
-    } else {
-      result["description"] = summary
-    }
-  } else if description, ok := props.Function["description"].(string); ok {
-    result["description"] = description
-  }
-  if deprecated, ok := props.Function["deprecated"].(bool); ok && deprecated {
-    result["deprecated"] = true
-  }
-  if tags, ok := props.Function["tags"].([]any); ok && len(tags) != 0 {
-    result["tags"] = tags
-  }
-  return result
-}
-
-func llmApplicationProgrammer_writeParameters(props struct {
-  Context    nativecontext.ITypiaContext
-  Components *nativeiterate.OpenApi_IComponents
-  Function   map[string]any
-  Config     map[string]any
-}) any {
-  rawParameters, _ := props.Function["parameters"].([]any)
-  if len(rawParameters) == 0 {
-    return llmApplicationProgrammer_convertParameters(
-      props.Components,
-      nativeiterate.JsonSchema{"type": "object", "properties": map[string]any{}, "additionalProperties": false, "required": []any{}},
-      props.Config,
-    )
-  }
-  param, _ := rawParameters[0].(map[string]any)
-  var schema nativeiterate.JsonSchema
-  if raw, ok := param["schema"].(nativeiterate.JsonSchema); ok {
-    schema = raw
-  } else if raw, ok := param["schema"].(map[string]any); ok {
-    schema = nativeiterate.JsonSchema(raw)
-  } else {
-    schema = nativeiterate.JsonSchema{"type": "object", "properties": map[string]any{}, "additionalProperties": false, "required": []any{}}
-  }
-  if _, ok := schema["title"]; ok == false {
-    if title, ok := param["title"]; ok {
-      schema["title"] = title
-    }
-  }
-  if _, ok := schema["description"]; ok == false {
-    if description, ok := param["description"]; ok {
-      schema["description"] = description
-    }
-  }
-  return llmApplicationProgrammer_convertParameters(props.Components, schema, props.Config)
-}
-
-func llmApplicationProgrammer_writeOutput(props struct {
-  Context    nativecontext.ITypiaContext
-  Components *nativeiterate.OpenApi_IComponents
-  Schema     nativeiterate.JsonSchema
-  Output     map[string]any
-  Config     map[string]any
-}) any {
-  if _, exists := props.Schema["description"]; exists == false {
-    if desc, ok := props.Output["description"].(string); ok && desc != "" {
-      props.Schema["description"] = desc
-    }
-  }
-  return llmApplicationProgrammer_convertParameters(props.Components, props.Schema, props.Config)
-}
-
-func llmApplicationProgrammer_convertParameters(
-  components *nativeiterate.OpenApi_IComponents,
-  schema nativeiterate.JsonSchema,
-  config map[string]any,
-) map[string]any {
-  defs := map[string]any{}
-  target := llmParametersProgrammer_dereference_schema(schema, components)
-  output := llmSchemaProgrammer_convert_schema_config(target, components, defs, config)
-  output["additionalProperties"] = false
-  output["$defs"] = defs
-  return output
-}
-
-func llmApplicationProgrammer_writeValidator(props struct {
-  Context   nativecontext.ITypiaContext
-  Modulo    *shimast.Node
-  Parameter *schemametadata.MetadataParameter
-  Name      string
-  Equals    bool
-  ClassName *string
-}) *shimast.Node {
-  if props.Parameter == nil || props.Parameter.TsType == nil {
-    typ := props.Context.Checker.GetAnyType()
-    return nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
-      Context: props.Context,
-      Modulo:  props.Modulo,
-      Type:    typ,
-      Name:    nil,
-      Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: props.Equals},
-    })
-  }
-  var name *string
-  if props.ClassName != nil {
-    text := fmt.Sprintf("Parameters<%s[%q]>[0]", *props.ClassName, props.Name)
-    name = &text
-  }
-  return nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
-    Context: props.Context,
-    Modulo:  props.Modulo,
-    Type:    props.Parameter.TsType,
-    Name:    name,
-    Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: props.Equals},
-  })
-}
-
-func llmApplicationProgrammer_validateObjectSchema(prefix string, label string, schema *schemametadata.MetadataSchema) []string {
-  errors := []string{}
-  if schema.IsRequired() == false {
-    errors = append(errors, prefix+" "+label+" cannot be optional (union with undefined).")
-  }
-  if schema.Nullable {
-    errors = append(errors, prefix+" "+label+" cannot be nullable.")
-  }
-  if schema.Size() != 1 || len(schema.Objects) != 1 {
-    errors = append(errors, prefix+" "+label+" must be a single object type.")
-  } else {
-    for _, property := range schema.Objects[0].Type.Properties {
-      if property.Key.IsSoleLiteral() == false {
-        errors = append(errors, prefix+" "+label+" cannot have dynamic property keys.")
-        break
-      }
-    }
-  }
-  return errors
-}
-
-func llmApplicationProgrammer_validateFunction(name string, fn *schemametadata.MetadataFunction) []string {
-  messages := []string{}
-  prefix := fmt.Sprintf("LLM application's function (%q)", name)
-  messages = append(messages, llmApplicationProgrammer_validateName(prefix, name)...)
-  if fn.Output != nil && fn.Output.Size() != 0 {
-    messages = append(messages, llmApplicationProgrammer_validateObjectSchema(prefix, "return type", fn.Output)...)
-  }
-  if len(fn.Parameters) != 0 && len(fn.Parameters) != 1 {
-    messages = append(messages, prefix+" must have exactly one parameter or no parameters.")
-  }
-  if len(fn.Parameters) != 0 {
-    messages = append(messages, llmApplicationProgrammer_validateObjectSchema(prefix, "parameter", fn.Parameters[0].Type)...)
-  }
-  return messages
-}
-
-var llmApplicationProgrammer_namePattern = regexp.MustCompile(`^[a-zA-Z0-9_-]+$`)
-
-func llmApplicationProgrammer_validateName(prefix string, name string) []string {
-  output := []string{}
-  if len(name) != 0 && name[0] >= '0' && name[0] <= '9' {
-    output = append(output, prefix+" name cannot start with a number.")
-  }
-  if llmApplicationProgrammer_namePattern.MatchString(name) == false {
-    output = append(output, prefix+" name must contain only alphanumeric characters, underscores, or hyphens.")
-  }
-  if len(name) > 64 {
-    output = append(output, prefix+" name cannot exceed 64 characters.")
-  }
-  return output
-}
-
-func llmApplicationProgrammer_propertyDescription(property *schemametadata.MetadataProperty) *string {
-  return llmApplicationProgrammer_describe(property.Description, property.JsDocTags)
-}
-
-func llmApplicationProgrammer_describe(description *string, jsDocTags []schemametadata.IJsDocTagInfo) *string {
-  if description == nil {
-    for _, tag := range jsDocTags {
-      if tag.Name == "description" && len(tag.Text) != 0 {
-        text := tag.Text[0].Text
-        description = &text
-        break
-      }
-    }
-  }
-  desc := nativejson.JsonApplicationProgrammer.WriteDescription(struct {
-    Description *string
-    JsDocTags   []schemametadata.IJsDocTagInfo
-    Kind        string
-  }{Description: description, JsDocTags: jsDocTags, Kind: "summary"})
-  var summary *string
-  if s, ok := desc["summary"].(string); ok {
-    summary = &s
-  }
-  if d, ok := desc["description"].(string); ok {
-    description = &d
-  }
-  return llmProgrammer_concat_description(summary, description)
-}
-
-func llmApplicationProgrammer_hidden(tags []schemametadata.IJsDocTagInfo) bool {
-  for _, tag := range tags {
-    if tag.Name == "hidden" || tag.Name == "ignore" || tag.Name == "internal" {
-      return true
-    }
-  }
-  return false
-}
-
-func llmApplicationProgrammer_equals(config map[string]any) bool {
-  if config == nil {
-    return false
-  }
-  value, _ := config["equals"].(bool)
-  return value
-}
+package llm
+
+import (
+  "fmt"
+  "regexp"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+  nativejson "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type llmApplicationProgrammerNamespace struct{}
+
+var LlmApplicationProgrammer = llmApplicationProgrammerNamespace{}
+
+type LlmApplicationProgrammer_IProps struct {
+  Context nativecontext.ITypiaContext
+  Modulo  *shimast.Node
+  Type    any
+  Name    *string
+  Init    *shimast.Node
+  Config  map[string]any
+}
+
+type LlmApplicationProgrammer_IWriteProps struct {
+  Context        nativecontext.ITypiaContext
+  Modulo         *shimast.Node
+  Metadata       *schemametadata.MetadataSchema
+  Config         map[string]any
+  Name           *string
+  ConfigArgument *shimast.Node
+}
+
+var llmApplicationProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (llmApplicationProgrammerNamespace) Write(props LlmApplicationProgrammer_IWriteProps) *shimast.Node {
+  application := LlmApplicationProgrammer.WriteApplication(struct {
+    Context  nativecontext.ITypiaContext
+    Modulo   *shimast.Node
+    Metadata *schemametadata.MetadataSchema
+    Config   map[string]any
+    Name     *string
+  }{
+    Context:  props.Context,
+    Modulo:   props.Modulo,
+    Metadata: props.Metadata,
+    Config:   props.Config,
+    Name:     props.Name,
+  })
+  f := nativecontext.EmitFactoryOf(llmApplicationProgrammer_factory, props.Context.Emit)
+  var arguments []*shimast.TypeNode
+  if props.Name != nil {
+    arguments = []*shimast.TypeNode{llmProgrammer_type_reference(*props.Name, props.Context.Emit)}
+  }
+  typeNode := llmProgrammer_import_type(props.Context, nativecontext.ImportProgrammer_TypeProps{
+    File:      "typia",
+    Name:      "ILlmApplication.__IPrimitive",
+    Arguments: arguments,
+  })
+  args := []*shimast.Node{
+    f.NewAsExpression(
+      f.NewSatisfiesExpression(nativefactories.LiteralFactory.Write(application, props.Context.Emit), typeNode),
+      typeNode,
+    ),
+  }
+  if props.ConfigArgument != nil {
+    args = append(args, props.ConfigArgument)
+  }
+  var typeArguments *shimast.NodeList
+  if props.Name != nil {
+    typeArguments = f.NewNodeList([]*shimast.Node{llmProgrammer_type_reference(*props.Name, props.Context.Emit)})
+  }
+  return f.NewCallExpression(
+    llmProgrammer_internal(props.Context, "llmApplicationFinalize"),
+    nil,
+    typeArguments,
+    f.NewNodeList(args),
+    shimast.NodeFlagsNone,
+  )
+}
+
+func (llmApplicationProgrammerNamespace) Validate(props struct {
+  Config   map[string]any
+  Metadata *schemametadata.MetadataSchema
+  Explore  nativefactories.MetadataFactory_IExplore
+  Top      *schemametadata.MetadataSchema
+}) []string {
+  if props.Explore.Top == false {
+    if props.Top != nil &&
+      len(props.Top.Objects) != 0 &&
+      props.Explore.Object == props.Top.Objects[0].Type {
+      if _, ok := props.Explore.Property.(string); ok &&
+        props.Metadata.Size() == 1 &&
+        props.Metadata.Nullable == false &&
+        props.Metadata.IsRequired() == true &&
+        len(props.Metadata.Functions) == 1 {
+        return llmApplicationProgrammer_validateFunction(fmt.Sprint(props.Explore.Property), props.Metadata.Functions[0])
+      }
+    }
+    return LlmSchemaProgrammer.Validate(struct {
+      Config   map[string]any
+      Metadata *schemametadata.MetadataSchema
+      Explore  nativefactories.MetadataFactory_IExplore
+    }{Config: props.Config, Metadata: props.Metadata, Explore: props.Explore})
+  }
+
+  output := []string{}
+  isValidType := props.Metadata.Size() == 1 &&
+    len(props.Metadata.Objects) == 1 &&
+    props.Metadata.IsRequired() == true &&
+    props.Metadata.Nullable == false
+  if isValidType == false {
+    output = append(output, "LLM application's generic argument must be a class/interface type.")
+  }
+  var object *schemametadata.MetadataObjectType
+  if len(props.Metadata.Objects) != 0 {
+    object = props.Metadata.Objects[0].Type
+  }
+  if object != nil {
+    for _, property := range object.Properties {
+      if property.Key.IsSoleLiteral() == false {
+        output = append(output, "LLM application does not allow dynamic keys on class/interface type.")
+        break
+      }
+    }
+    least := false
+    for _, property := range object.Properties {
+      rawName := property.Key.GetSoleLiteral()
+      if rawName == nil {
+        continue
+      }
+      value := property.Value
+      if len(value.Functions) == 0 {
+        continue
+      }
+      least = true
+      name := fmt.Sprintf("%q", *rawName)
+      if isValidType == false {
+        if len(value.Functions) != 1 || value.Size() != 1 {
+          output = append(output, "LLM application's function ("+name+") type does not allow union type.")
+        }
+        if value.IsRequired() == false {
+          output = append(output, "LLM application's function ("+name+") type must be required.")
+        }
+        if value.Nullable {
+          output = append(output, "LLM application's function ("+name+") type must not be nullable.")
+        }
+      }
+      prefix := "LLM application's function (" + name + ")"
+      output = append(output, llmApplicationProgrammer_validateName(prefix, *rawName)...)
+      description := llmApplicationProgrammer_propertyDescription(property)
+      if description != nil && len(*description) > 1024 {
+        output = append(output, "LLM application's function ("+name+") description must not exceed 1,024 characters.")
+      }
+    }
+    if least == false {
+      output = append(output, "LLM application's target type must have at least a function type.")
+    }
+  }
+  return output
+}
+
+func (llmApplicationProgrammerNamespace) WriteApplication(props struct {
+  Context  nativecontext.ITypiaContext
+  Modulo   *shimast.Node
+  Metadata *schemametadata.MetadataSchema
+  Config   map[string]any
+  Name     *string
+}) map[string]any {
+  metadata := schemametadata.MetadataSchema_unalias(props.Metadata)
+  functionParameters := map[string]*schemametadata.MetadataParameter{}
+  if len(metadata.Objects) != 0 {
+    for _, property := range metadata.Objects[0].Type.Properties {
+      if property.Key.IsSoleLiteral() == false ||
+        property.Value.Size() != 1 ||
+        property.Value.Nullable ||
+        property.Value.IsRequired() == false {
+        continue
+      }
+      unaliased := schemametadata.MetadataSchema_unalias(property.Value)
+      if len(unaliased.Functions) != 1 || llmApplicationProgrammer_hidden(property.JsDocTags) {
+        continue
+      }
+      key := property.Key.GetSoleLiteral()
+      if key == nil || len(unaliased.Functions[0].Parameters) == 0 {
+        continue
+      }
+      functionParameters[*key] = unaliased.Functions[0].Parameters[0]
+    }
+  }
+  application := nativejson.JsonApplicationProgrammer.WriteApplication(struct {
+    Version  string
+    Metadata *schemametadata.MetadataSchema
+    Filter   func(prop *schemametadata.MetadataProperty) bool
+  }{
+    Version:  "3.1",
+    Metadata: metadata,
+    Filter: func(prop *schemametadata.MetadataProperty) bool {
+      for _, tag := range prop.JsDocTags {
+        if tag.Name == "human" {
+          return false
+        }
+      }
+      return true
+    },
+  })
+  components, _ := application["components"].(*nativeiterate.OpenApi_IComponents)
+  rawFunctions, _ := application["functions"].([]any)
+  functions := []any{}
+  for _, raw := range rawFunctions {
+    fn, ok := raw.(map[string]any)
+    if ok == false {
+      continue
+    }
+    name, _ := fn["name"].(string)
+    written := llmApplicationProgrammer_writeFunction(struct {
+      Context    nativecontext.ITypiaContext
+      Modulo     *shimast.Node
+      Components *nativeiterate.OpenApi_IComponents
+      Function   map[string]any
+      Parameter  *schemametadata.MetadataParameter
+      ClassName  *string
+      Config     map[string]any
+    }{
+      Context:    props.Context,
+      Modulo:     props.Modulo,
+      Components: components,
+      Function:   fn,
+      Parameter:  functionParameters[name],
+      ClassName:  props.Name,
+      Config:     props.Config,
+    })
+    if written != nil {
+      functions = append(functions, written)
+    }
+  }
+  result := map[string]any{"functions": functions}
+  if len(metadata.Objects) != 0 {
+    if object := metadata.Objects[0].Type; object != nil {
+      if description := llmApplicationProgrammer_describe(object.Description, object.JsDocTags); description != nil && len(*description) != 0 {
+        result["description"] = *description
+      }
+    }
+  }
+  return result
+}
+
+func llmApplicationProgrammer_writeFunction(props struct {
+  Context    nativecontext.ITypiaContext
+  Modulo     *shimast.Node
+  Components *nativeiterate.OpenApi_IComponents
+  Function   map[string]any
+  Parameter  *schemametadata.MetadataParameter
+  ClassName  *string
+  Config     map[string]any
+}) map[string]any {
+  name, _ := props.Function["name"].(string)
+  parameters := llmApplicationProgrammer_writeParameters(struct {
+    Context    nativecontext.ITypiaContext
+    Components *nativeiterate.OpenApi_IComponents
+    Function   map[string]any
+    Config     map[string]any
+  }{
+    Context:    props.Context,
+    Components: props.Components,
+    Function:   props.Function,
+    Config:     props.Config,
+  })
+  var output any
+  if raw, ok := props.Function["output"].(map[string]any); ok {
+    if schema, ok := raw["schema"].(nativeiterate.JsonSchema); ok {
+      output = llmApplicationProgrammer_writeOutput(struct {
+        Context    nativecontext.ITypiaContext
+        Components *nativeiterate.OpenApi_IComponents
+        Schema     nativeiterate.JsonSchema
+        Output     map[string]any
+        Config     map[string]any
+      }{Context: props.Context, Components: props.Components, Schema: schema, Output: raw, Config: props.Config})
+    } else if schema, ok := raw["schema"].(map[string]any); ok {
+      output = llmApplicationProgrammer_writeOutput(struct {
+        Context    nativecontext.ITypiaContext
+        Components *nativeiterate.OpenApi_IComponents
+        Schema     nativeiterate.JsonSchema
+        Output     map[string]any
+        Config     map[string]any
+      }{Context: props.Context, Components: props.Components, Schema: nativeiterate.JsonSchema(schema), Output: raw, Config: props.Config})
+    }
+  }
+  result := map[string]any{
+    "name":       name,
+    "parameters": parameters,
+    "validate": llmApplicationProgrammer_writeValidator(struct {
+      Context   nativecontext.ITypiaContext
+      Modulo    *shimast.Node
+      Parameter *schemametadata.MetadataParameter
+      Name      string
+      Equals    bool
+      ClassName *string
+    }{
+      Context:   props.Context,
+      Modulo:    props.Modulo,
+      Parameter: props.Parameter,
+      Name:      name,
+      Equals:    llmApplicationProgrammer_equals(props.Config),
+      ClassName: props.ClassName,
+    }),
+  }
+  if output != nil {
+    result["output"] = output
+  }
+  if summary, ok := props.Function["summary"].(string); ok {
+    if description, ok := props.Function["description"].(string); ok {
+      result["description"] = *llmProgrammer_concat_description(&summary, &description)
+    } else {
+      result["description"] = summary
+    }
+  } else if description, ok := props.Function["description"].(string); ok {
+    result["description"] = description
+  }
+  if deprecated, ok := props.Function["deprecated"].(bool); ok && deprecated {
+    result["deprecated"] = true
+  }
+  if tags, ok := props.Function["tags"].([]any); ok && len(tags) != 0 {
+    result["tags"] = tags
+  }
+  return result
+}
+
+func llmApplicationProgrammer_writeParameters(props struct {
+  Context    nativecontext.ITypiaContext
+  Components *nativeiterate.OpenApi_IComponents
+  Function   map[string]any
+  Config     map[string]any
+}) any {
+  rawParameters, _ := props.Function["parameters"].([]any)
+  if len(rawParameters) == 0 {
+    return llmApplicationProgrammer_convertParameters(
+      props.Components,
+      nativeiterate.JsonSchema{"type": "object", "properties": map[string]any{}, "additionalProperties": false, "required": []any{}},
+      props.Config,
+    )
+  }
+  param, _ := rawParameters[0].(map[string]any)
+  var schema nativeiterate.JsonSchema
+  if raw, ok := param["schema"].(nativeiterate.JsonSchema); ok {
+    schema = raw
+  } else if raw, ok := param["schema"].(map[string]any); ok {
+    schema = nativeiterate.JsonSchema(raw)
+  } else {
+    schema = nativeiterate.JsonSchema{"type": "object", "properties": map[string]any{}, "additionalProperties": false, "required": []any{}}
+  }
+  if _, ok := schema["title"]; ok == false {
+    if title, ok := param["title"]; ok {
+      schema["title"] = title
+    }
+  }
+  if _, ok := schema["description"]; ok == false {
+    if description, ok := param["description"]; ok {
+      schema["description"] = description
+    }
+  }
+  return llmApplicationProgrammer_convertParameters(props.Components, schema, props.Config)
+}
+
+func llmApplicationProgrammer_writeOutput(props struct {
+  Context    nativecontext.ITypiaContext
+  Components *nativeiterate.OpenApi_IComponents
+  Schema     nativeiterate.JsonSchema
+  Output     map[string]any
+  Config     map[string]any
+}) any {
+  if _, exists := props.Schema["description"]; exists == false {
+    if desc, ok := props.Output["description"].(string); ok && desc != "" {
+      props.Schema["description"] = desc
+    }
+  }
+  return llmApplicationProgrammer_convertParameters(props.Components, props.Schema, props.Config)
+}
+
+func llmApplicationProgrammer_convertParameters(
+  components *nativeiterate.OpenApi_IComponents,
+  schema nativeiterate.JsonSchema,
+  config map[string]any,
+) map[string]any {
+  defs := map[string]any{}
+  target := llmParametersProgrammer_dereference_schema(schema, components)
+  output := llmSchemaProgrammer_convert_schema_config(target, components, defs, config)
+  output["additionalProperties"] = false
+  output["$defs"] = defs
+  return output
+}
+
+func llmApplicationProgrammer_writeValidator(props struct {
+  Context   nativecontext.ITypiaContext
+  Modulo    *shimast.Node
+  Parameter *schemametadata.MetadataParameter
+  Name      string
+  Equals    bool
+  ClassName *string
+}) *shimast.Node {
+  if props.Parameter == nil || props.Parameter.TsType == nil {
+    typ := props.Context.Checker.GetAnyType()
+    return nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
+      Context: props.Context,
+      Modulo:  props.Modulo,
+      Type:    typ,
+      Name:    nil,
+      Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: props.Equals},
+    })
+  }
+  var name *string
+  if props.ClassName != nil {
+    text := fmt.Sprintf("Parameters<%s[%q]>[0]", *props.ClassName, props.Name)
+    name = &text
+  }
+  return nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
+    Context: props.Context,
+    Modulo:  props.Modulo,
+    Type:    props.Parameter.TsType,
+    Name:    name,
+    Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: props.Equals},
+  })
+}
+
+func llmApplicationProgrammer_validateObjectSchema(prefix string, label string, schema *schemametadata.MetadataSchema) []string {
+  errors := []string{}
+  if schema.IsRequired() == false {
+    errors = append(errors, prefix+" "+label+" cannot be optional (union with undefined).")
+  }
+  if schema.Nullable {
+    errors = append(errors, prefix+" "+label+" cannot be nullable.")
+  }
+  if schema.Size() != 1 || len(schema.Objects) != 1 {
+    errors = append(errors, prefix+" "+label+" must be a single object type.")
+  } else {
+    for _, property := range schema.Objects[0].Type.Properties {
+      if property.Key.IsSoleLiteral() == false {
+        errors = append(errors, prefix+" "+label+" cannot have dynamic property keys.")
+        break
+      }
+    }
+  }
+  return errors
+}
+
+func llmApplicationProgrammer_validateFunction(name string, fn *schemametadata.MetadataFunction) []string {
+  messages := []string{}
+  prefix := fmt.Sprintf("LLM application's function (%q)", name)
+  messages = append(messages, llmApplicationProgrammer_validateName(prefix, name)...)
+  if fn.Output != nil && fn.Output.Size() != 0 {
+    messages = append(messages, llmApplicationProgrammer_validateObjectSchema(prefix, "return type", fn.Output)...)
+  }
+  if len(fn.Parameters) != 0 && len(fn.Parameters) != 1 {
+    messages = append(messages, prefix+" must have exactly one parameter or no parameters.")
+  }
+  if len(fn.Parameters) != 0 {
+    messages = append(messages, llmApplicationProgrammer_validateObjectSchema(prefix, "parameter", fn.Parameters[0].Type)...)
+  }
+  return messages
+}
+
+var llmApplicationProgrammer_namePattern = regexp.MustCompile(`^[a-zA-Z0-9_-]+$`)
+
+func llmApplicationProgrammer_validateName(prefix string, name string) []string {
+  output := []string{}
+  if len(name) != 0 && name[0] >= '0' && name[0] <= '9' {
+    output = append(output, prefix+" name cannot start with a number.")
+  }
+  if llmApplicationProgrammer_namePattern.MatchString(name) == false {
+    output = append(output, prefix+" name must contain only alphanumeric characters, underscores, or hyphens.")
+  }
+  if len(name) > 64 {
+    output = append(output, prefix+" name cannot exceed 64 characters.")
+  }
+  return output
+}
+
+func llmApplicationProgrammer_propertyDescription(property *schemametadata.MetadataProperty) *string {
+  return llmApplicationProgrammer_describe(property.Description, property.JsDocTags)
+}
+
+func llmApplicationProgrammer_describe(description *string, jsDocTags []schemametadata.IJsDocTagInfo) *string {
+  if description == nil {
+    for _, tag := range jsDocTags {
+      if tag.Name == "description" && len(tag.Text) != 0 {
+        text := tag.Text[0].Text
+        description = &text
+        break
+      }
+    }
+  }
+  desc := nativejson.JsonApplicationProgrammer.WriteDescription(struct {
+    Description *string
+    JsDocTags   []schemametadata.IJsDocTagInfo
+    Kind        string
+  }{Description: description, JsDocTags: jsDocTags, Kind: "summary"})
+  var summary *string
+  if s, ok := desc["summary"].(string); ok {
+    summary = &s
+  }
+  if d, ok := desc["description"].(string); ok {
+    description = &d
+  }
+  return llmProgrammer_concat_description(summary, description)
+}
+
+func llmApplicationProgrammer_hidden(tags []schemametadata.IJsDocTagInfo) bool {
+  for _, tag := range tags {
+    if tag.Name == "hidden" || tag.Name == "ignore" || tag.Name == "internal" {
+      return true
+    }
+  }
+  return false
+}
+
+func llmApplicationProgrammer_equals(config map[string]any) bool {
+  if config == nil {
+    return false
+  }
+  value, _ := config["equals"].(bool)
+  return value
+}