typia 15.0.0 → 15.1.0

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

@@ -17,15 +17,16 @@ 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
-}
-
+// LlmApplicationProgrammer_IWriteProps is the argument record of
+// LlmApplicationProgrammer.Write, which builds the LLM function-calling
+// application of a class type. Config is the call's literal configuration, Name
+// the written class name and ConfigArgument the configuration expression that is
+// passed through to the generated call.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of LlmApplicationProgrammer.Write, which builds the LLM function-calling application of a class type; its 6 fields (Context, Modulo, Metadata, Config, Name, ConfigArgument) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 6-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type LlmApplicationProgrammer_IWriteProps struct {
   Context        nativecontext.ITypiaContext
   Modulo         *shimast.Node

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

@@ -13,15 +13,14 @@ type llmCoerceProgrammerNamespace struct{}
 
 var LlmCoerceProgrammer = llmCoerceProgrammerNamespace{}
 
-type LlmCoerceProgrammer_IProps struct {
-  Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    any
-  Name    *string
-  Init    *shimast.Node
-  Config  map[string]any
-}
-
+// LlmCoerceProgrammer_DecomposeProps is the argument record of
+// LlmCoerceProgrammer.Decompose, which builds the `llm.coerce` function. Config
+// is the call's literal configuration.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of LlmCoerceProgrammer.Decompose, which builds the `llm.coerce` function; its 6 fields (Context, Config, Modulo, Functor, Metadata, Name) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 6-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type LlmCoerceProgrammer_DecomposeProps struct {
   Context  nativecontext.ITypiaContext
   Config   map[string]any
@@ -31,6 +30,14 @@ type LlmCoerceProgrammer_DecomposeProps struct {
   Name     *string
 }
 
+// LlmCoerceProgrammer_IWriteProps is the argument record of
+// LlmCoerceProgrammer.Write, which builds the `llm.coerce` function. Config is
+// the call's literal configuration.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of LlmCoerceProgrammer.Write, which builds the `llm.coerce` function; its 5 fields (Context, Modulo, Metadata, Config, Name) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 5-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type LlmCoerceProgrammer_IWriteProps struct {
   Context  nativecontext.ITypiaContext
   Modulo   *shimast.Node

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

@@ -10,6 +10,16 @@ type llmControllerProgrammerNamespace struct{}
 
 var LlmControllerProgrammer = llmControllerProgrammerNamespace{}
 
+// LlmControllerProgrammer_IWriteProps is the argument record of
+// LlmControllerProgrammer.Write, which builds the LLM controller of a class.
+// NameArgument and ExecuteArgument are the `name` and `execute` expressions of
+// the controller, ConfigArgument is the configuration expression and Node is the
+// class type node.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of LlmControllerProgrammer.Write, which builds the LLM controller of a class; its 9 fields (Context, Modulo, Metadata, Config, ClassName, Node, NameArgument, ExecuteArgument, ConfigArgument) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 9-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type LlmControllerProgrammer_IWriteProps struct {
   Context         nativecontext.ITypiaContext
   Modulo          *shimast.Node

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

@@ -12,6 +12,7 @@ import (
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
   nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 type llmEvaluationProgrammerNamespace struct{}
@@ -19,19 +20,45 @@ type llmEvaluationProgrammerNamespace struct{}
 // LlmEvaluationProgrammer writes `typia.llm.evaluation<T>()`.
 //
 // The emitted code is one call to the `_createLlmEvaluation` runtime helper
-// with a compile-time plan: one entry per decision leaf of `T`, carrying its
-// property path, question text, and probability requirements. The helper
+// with the configured decimals and a compile-time plan: one entry per decision
+// leaf of `T`, carrying its property path, question text, and probability
+// requirements. The helper
 // derives both the question map and the checked decoder from that plan,
 // so the question-key encoding has a single owner at runtime.
 var LlmEvaluationProgrammer = llmEvaluationProgrammerNamespace{}
 
+// LlmEvaluationProgrammer_IWriteProps is the argument record of
+// LlmEvaluationProgrammer.Write, which builds the evaluation function of a
+// decision type.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of LlmEvaluationProgrammer.Write, which builds the evaluation function of a decision type; its 4 fields (Context, Metadata, Name, Config) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 4-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is.
 type LlmEvaluationProgrammer_IWriteProps struct {
   Context  nativecontext.ITypiaContext
   Metadata *schemametadata.MetadataSchema
   Name     *string
+  Config   LlmEvaluationProgrammer_IConfig
+}
+
+// LlmEvaluationProgrammer_IConfig is `ILlmEvaluation.IConfig`: the decimal
+// places of the evaluation model's answers, two by default.
+//
+// @evidence contracts/common.md#principled-implementation It is the configuration of the evaluation function, which is the number of decimal places of the evaluation model's answers; its 1 fields (Decimals) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 1-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is.
+type LlmEvaluationProgrammer_IConfig struct {
+  Decimals int
 }
 
 // LlmEvaluationProgrammer_IError is one rejected position of the decision type.
+//
+// @evidence contracts/common.md#principled-implementation It is one rejected position of the decision type, with its validation path and its message; its 2 fields (Accessor, Message) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 2-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is.
 type LlmEvaluationProgrammer_IError struct {
   // Accessor is the typia validation path of the position, like
   // `$input.refund.requested`.
@@ -41,22 +68,24 @@ type LlmEvaluationProgrammer_IError struct {
 
 var llmEvaluationProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
-// Write emits `_createLlmEvaluation(plan) as ILlmEvaluation<T>`. The metadata
-// must already have passed Compose without errors.
+// Write emits `_createLlmEvaluation(plan, decimals) as ILlmEvaluation<T>`.
+// The metadata must already have passed Compose without errors.
 func (llmEvaluationProgrammerNamespace) Write(props LlmEvaluationProgrammer_IWriteProps, plan []any) *shimast.Node {
   f := nativecontext.EmitFactoryOf(llmEvaluationProgrammer_factory, props.Context.Emit)
   typeName := "unknown"
   if props.Name != nil {
     typeName = *props.Name
   }
+  arguments := []*shimast.Node{
+    nativefactories.LiteralFactory.Write(plan, props.Context.Emit),
+  }
+  arguments = append(arguments, nativefactories.LiteralFactory.Write(float64(props.Config.Decimals), props.Context.Emit))
   return f.NewAsExpression(
     f.NewCallExpression(
       llmProgrammer_internal(props.Context, "createLlmEvaluation"),
       nil,
       nil,
-      f.NewNodeList([]*shimast.Node{
-        nativefactories.LiteralFactory.Write(plan, props.Context.Emit),
-      }),
+      f.NewNodeList(arguments),
       shimast.NodeFlagsNone,
     ),
     llmProgrammer_import_type(props.Context, nativecontext.ImportProgrammer_TypeProps{
@@ -69,8 +98,9 @@ func (llmEvaluationProgrammerNamespace) Write(props LlmEvaluationProgrammer_IWri
 
 // Compose walks the decision type and returns the evaluation plan, or every
 // position an evaluation model cannot answer.
-func (llmEvaluationProgrammerNamespace) Compose(metadata *schemametadata.MetadataSchema) ([]any, []LlmEvaluationProgrammer_IError) {
+func (llmEvaluationProgrammerNamespace) Compose(metadata *schemametadata.MetadataSchema, config LlmEvaluationProgrammer_IConfig) ([]any, []LlmEvaluationProgrammer_IError) {
   composer := &llmEvaluationComposer{
+    config:  config,
     plan:    []any{},
     visited: map[*schemametadata.MetadataObjectType]bool{},
   }
@@ -94,6 +124,7 @@ func (llmEvaluationProgrammerNamespace) Message(errors []LlmEvaluationProgrammer
 }
 
 type llmEvaluationComposer struct {
+  config  LlmEvaluationProgrammer_IConfig
   plan    []any
   errors  []LlmEvaluationProgrammer_IError
   visited map[*schemametadata.MetadataObjectType]bool
@@ -227,11 +258,20 @@ func (c *llmEvaluationComposer) property(property *schemametadata.MetadataProper
       c.fail(accessor, "LLM evaluation boolean has both tags.Probability and @probability; keep only one.")
       return
     }
+    // rows are union alternatives, so `(true & A) | false` or
+    // `(true & A) | (false & B)` states no single threshold
+    if found && len(value.Atomics[0].Tags) > 1 {
+      c.fail(accessor, "LLM evaluation boolean has different tags.Probability on true and false; put one on boolean.")
+      return
+    }
     if found {
       threshold = tagged
     } else if hasFallback {
       threshold = fallback
     }
+    if found || hasFallback {
+      c.grid(accessor, threshold)
+    }
     leaf["threshold"] = threshold
   case "choice", "score", "set":
     constant := value.Constants
@@ -239,6 +279,24 @@ func (c *llmEvaluationComposer) property(property *schemametadata.MetadataProper
       constant = llmEvaluation_unalias(value.Arrays[0].Type.Value).Constants
     }
     entries := constant[0].Values
+    // TypeSafe's Jev rejects a choice above 255 options and a score above 10
+    // levels, so a larger one only fails when the provider is called
+    if kind == "choice" && len(entries) > llmEvaluation_maxChoiceOptions {
+      c.fail(accessor, fmt.Sprintf(
+        "LLM evaluation does not support a choice of %d options, because an evaluation model accepts at most %d.",
+        len(entries),
+        llmEvaluation_maxChoiceOptions,
+      ))
+      return
+    }
+    if kind == "score" && len(entries) > llmEvaluation_maxScoreLevels {
+      c.fail(accessor, fmt.Sprintf(
+        "LLM evaluation does not support a score of %d levels, because an evaluation model accepts at most %d.",
+        len(entries),
+        llmEvaluation_maxScoreLevels,
+      ))
+      return
+    }
     if kind == "score" {
       entries = append([]*schemametadata.MetadataConstantValue{}, entries...)
       sort.SliceStable(entries, func(i, j int) bool {
@@ -247,6 +305,10 @@ func (c *llmEvaluationComposer) property(property *schemametadata.MetadataProper
         return left < right
       })
     }
+    // the property default is one declaration however many members inherit it
+    if hasFallback {
+      c.grid(accessor, fallback)
+    }
     members := make([]any, 0, len(entries))
     hasMemberRequirement := false
     missingRequirements := make([]*schemametadata.MetadataConstantValue, 0)
@@ -255,6 +317,13 @@ func (c *llmEvaluationComposer) property(property *schemametadata.MetadataProper
         c.fail(accessor, fmt.Sprintf("%s (member %s)", message, llmEvaluation_value_text(entry.Value)))
         continue
       }
+      if entry.Duplicated {
+        c.fail(accessor, fmt.Sprintf(
+          "LLM evaluation does not support enum members or literals sharing the value %s, because their descriptions and probability requirements would collide.",
+          llmEvaluation_value_text(entry.Value),
+        ))
+        continue
+      }
       member := map[string]any{"value": llmEvaluation_value(entry.Value)}
       // an undocumented score level is described by its value, which the
       // runtime writes with JavaScript's own number formatting
@@ -266,7 +335,9 @@ func (c *llmEvaluationComposer) property(property *schemametadata.MetadataProper
         c.fail(accessor, fmt.Sprintf("%s (member %s)", message, llmEvaluation_value_text(entry.Value)))
         continue
       }
-      if found == false && hasFallback {
+      if found {
+        c.grid(accessor, requirement)
+      } else if hasFallback {
         requirement, found = fallback, true
       }
       if found {
@@ -297,6 +368,28 @@ func (c *llmEvaluationComposer) property(property *schemametadata.MetadataProper
   c.plan = append(c.plan, leaf)
 }
 
+// The largest choice and score TypeSafe's API accepts.
+const (
+  llmEvaluation_maxChoiceOptions = 255
+  llmEvaluation_maxScoreLevels   = 10
+)
+
+// grid rejects a declared probability requirement finer than the configured
+// `decimals`, because the model's answers never resolve it. A
+// default the author did not write is never checked.
+func (c *llmEvaluationComposer) grid(accessor string, number float64) {
+  decimals := c.config.Decimals
+  scale := math.Pow10(decimals)
+  if math.Abs(number*scale-math.Round(number*scale)) <= 1e-9 {
+    return
+  }
+  c.fail(accessor, fmt.Sprintf(
+    "LLM evaluation probability requirement must use at most %d decimal places, the configured decimals, but got %s.",
+    decimals,
+    strconv.FormatFloat(number, 'f', -1, 64),
+  ))
+}
+
 // A decoded value is trusted as T, so every tag with a validation meaning
 // must either be enforced here or rejected. These kinds only annotate schema
 // documentation or other serializers; probability is enforced by the decoder.
@@ -449,10 +542,13 @@ func llmEvaluation_parse_jsdoc_probability(tags []schemametadata.IJsDocTagInfo)
   if len(texts) != 1 {
     return 0, false, "LLM evaluation @probability is declared more than once; keep only one."
   }
-  value, err := strconv.ParseFloat(texts[0], 64)
-  if err != nil || math.IsNaN(value) || math.IsInf(value, 0) {
+  // The same JavaScript `Number()` grammar every other numeric JSDoc tag reads
+  // (samchon/typia#2442); Go's float syntax would also admit `0x1p-1`.
+  reading := nativeutils.NumberUtil.Read(texts[0])
+  if reading.Numeric == false || reading.Finite == false {
     return 0, false, fmt.Sprintf("LLM evaluation @probability must be a number in [0, 1], but got %q.", texts[0])
   }
+  value := reading.Value
   if value < 0 || value > 1 {
     return 0, false, fmt.Sprintf("LLM evaluation @probability must be in [0, 1], but got %s.", texts[0])
   }

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

@@ -13,15 +13,14 @@ type llmParametersProgrammerNamespace struct{}
 
 var LlmParametersProgrammer = llmParametersProgrammerNamespace{}
 
-type LlmParametersProgrammer_IProps struct {
-  Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    any
-  Name    *string
-  Init    *shimast.Node
-  Config  map[string]any
-}
-
+// LlmParametersProgrammer_IWriteProps is the argument record of
+// LlmParametersProgrammer.Write, which builds the LLM parameters schema of a
+// type. Config is the call's literal configuration.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of LlmParametersProgrammer.Write, which builds the LLM parameters schema of a type; its 3 fields (Context, Metadata, Config) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 3-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type LlmParametersProgrammer_IWriteProps struct {
   Context  nativecontext.ITypiaContext
   Metadata *schemametadata.MetadataSchema

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

@@ -14,15 +14,14 @@ type llmParseProgrammerNamespace struct{}
 
 var LlmParseProgrammer = llmParseProgrammerNamespace{}
 
-type LlmParseProgrammer_IProps struct {
-  Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    any
-  Name    *string
-  Init    *shimast.Node
-  Config  map[string]any
-}
-
+// LlmParseProgrammer_DecomposeProps is the argument record of
+// LlmParseProgrammer.Decompose, which builds the `llm.parse` function. Config is
+// the call's literal configuration.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of LlmParseProgrammer.Decompose, which builds the `llm.parse` function; its 6 fields (Context, Config, Modulo, Functor, Metadata, Name) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 6-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type LlmParseProgrammer_DecomposeProps struct {
   Context  nativecontext.ITypiaContext
   Config   map[string]any
@@ -32,6 +31,14 @@ type LlmParseProgrammer_DecomposeProps struct {
   Name     *string
 }
 
+// LlmParseProgrammer_IWriteProps is the argument record of
+// LlmParseProgrammer.Write, which builds the `llm.parse` function. Config is the
+// call's literal configuration.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of LlmParseProgrammer.Write, which builds the `llm.parse` function; its 5 fields (Context, Modulo, Metadata, Config, Name) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 5-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type LlmParseProgrammer_IWriteProps struct {
   Context  nativecontext.ITypiaContext
   Modulo   *shimast.Node
@@ -113,6 +120,14 @@ func (llmParseProgrammerNamespace) Validate(props struct {
   return LlmParametersProgrammer.Validate(props)
 }
 
+// ImportTypeIParameters returns the import type request that refers to
+// `ILlmSchema.IParameters` of the typia package, using the emit context when one
+// is given.
+//
+// @evidence contracts/common.md#principled-implementation It returns the import type request that refers to `ILlmSchema.IParameters` of the typia package, using the emit context when one is given.
+// @evidence contracts/common.md#clear-and-simple-design One function returns the package and qualified type identifier together, shared by the parse and coerce schema declarations.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
+// @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
 func ImportTypeIParameters(emit ...*shimprinter.EmitContext) nativecontext.ImportProgrammer_TypeProps {
   return nativecontext.ImportProgrammer_TypeProps{
     File: "typia",

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

@@ -15,26 +15,34 @@ import (
   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"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 type llmSchemaProgrammerNamespace struct{}
 
 var LlmSchemaProgrammer = llmSchemaProgrammerNamespace{}
 
-type LlmSchemaProgrammer_IProps struct {
-  Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    any
-  Name    *string
-  Init    *shimast.Node
-  Config  map[string]any
-}
-
+// LlmSchemaProgrammer_IOutput is the converted LLM schema together with its
+// definitions. Schema is the schema of the type and Defs the named definitions
+// it refers to.
+//
+// @evidence contracts/common.md#principled-implementation It is the converted LLM schema together with its definitions; its 2 fields (Schema, Defs) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 2-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type LlmSchemaProgrammer_IOutput struct {
   Schema map[string]any
   Defs   map[string]any
 }
 
+// LlmSchemaProgrammer_IWriteProps is the argument record of
+// LlmSchemaProgrammer.Write, which builds the LLM schema of a type. Config is
+// the call's literal configuration.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of LlmSchemaProgrammer.Write, which builds the LLM schema of a type; its 3 fields (Context, Metadata, Config) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 3-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type LlmSchemaProgrammer_IWriteProps struct {
   Context  nativecontext.ITypiaContext
   Metadata *schemametadata.MetadataSchema
@@ -709,11 +717,11 @@ func llmSchemaProgrammer_shift_array(schema map[string]any) map[string]any {
   output := llmSchemaProgrammer_clone(schema)
   tags := []string{}
   if value, ok := output["minItems"]; ok {
-    tags = append(tags, "@minItems "+fmt.Sprint(value))
+    tags = append(tags, "@minItems "+llmSchemaProgrammer_tag_text(value))
     delete(output, "minItems")
   }
   if value, ok := output["maxItems"]; ok {
-    tags = append(tags, "@maxItems "+fmt.Sprint(value))
+    tags = append(tags, "@maxItems "+llmSchemaProgrammer_tag_text(value))
     delete(output, "maxItems")
   }
   if value, ok := output["uniqueItems"].(bool); ok {
@@ -732,7 +740,7 @@ func llmSchemaProgrammer_shift_numeric(schema map[string]any) map[string]any {
   tags := []string{}
   for _, key := range []string{"minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "default"} {
     if value, ok := output[key]; ok {
-      tags = append(tags, "@"+key+" "+fmt.Sprint(value))
+      tags = append(tags, "@"+key+" "+llmSchemaProgrammer_tag_text(value))
       delete(output, key)
     }
   }
@@ -745,7 +753,7 @@ func llmSchemaProgrammer_shift_string(schema map[string]any) map[string]any {
   tags := []string{}
   for _, key := range []string{"minLength", "maxLength", "format", "pattern", "contentMediaType", "default"} {
     if value, ok := output[key]; ok {
-      tags = append(tags, "@"+key+" "+fmt.Sprint(value))
+      tags = append(tags, "@"+key+" "+llmSchemaProgrammer_tag_text(value))
       delete(output, key)
     }
   }
@@ -753,6 +761,35 @@ func llmSchemaProgrammer_shift_string(schema map[string]any) map[string]any {
   return output
 }
 
+// llmSchemaProgrammer_tag_text writes a shifted constraint value as `@typia/utils`'
+// OpenApiConstraintShifter does, through JavaScript's template interpolation.
+//
+// A numeric literal from a type tag arrives as the compiler's `jsnum.Number`,
+// whose `String()` already follows JavaScript, but a comment tag's value is a
+// plain float64, and `fmt.Sprint` spells it the Go way: `1e+06` for 1000000,
+// `1e-07` for 1e-7, `+Inf` for an infinity (samchon/typia#2452). Every float is
+// therefore spelled by `NumberUtil.String`, whatever its defined type, and a
+// pointer is followed to the value it holds.
+func llmSchemaProgrammer_tag_text(value any) string {
+  reflected := reflect.ValueOf(value)
+  for reflected.IsValid() && reflected.Kind() == reflect.Pointer && reflected.IsNil() == false {
+    reflected = reflected.Elem()
+  }
+  if reflected.IsValid() == false {
+    return fmt.Sprint(value)
+  }
+  switch reflected.Kind() {
+  case reflect.Float32, reflect.Float64:
+    return nativeutils.NumberUtil.String(reflected.Float())
+  case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+    // JavaScript holds the count as a double, rounding past 2^53.
+    return nativeutils.NumberUtil.String(float64(reflected.Int()))
+  case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+    return nativeutils.NumberUtil.String(float64(reflected.Uint()))
+  }
+  return fmt.Sprint(reflected.Interface())
+}
+
 func llmSchemaProgrammer_write_tag_with_description(schema map[string]any, tags []string) {
   if len(tags) == 0 {
     return

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

@@ -15,15 +15,14 @@ type llmStructuredOutputProgrammerNamespace struct{}
 
 var LlmStructuredOutputProgrammer = llmStructuredOutputProgrammerNamespace{}
 
-type LlmStructuredOutputProgrammer_IProps struct {
-  Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    *shimchecker.Type
-  Name    *string
-  Init    *shimast.Node
-  Config  map[string]any
-}
-
+// LlmStructuredOutputProgrammer_IWriteProps is the argument record of
+// LlmStructuredOutputProgrammer.Write, which builds the structured output of a
+// type. Config is the call's literal configuration.
+//
+// @evidence contracts/common.md#principled-implementation It is the argument record of LlmStructuredOutputProgrammer.Write, which builds the structured output of a type; its 6 fields (Context, Modulo, Type, Metadata, Config, Name) are named so that a producer and a consumer cannot transpose them.
+// @evidence contracts/common.md#clear-and-simple-design A 6-field record with no methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record: it derives, defaults and validates nothing.
+// @evidence contracts/common.md#meaningful-documentation The doc states what the record is and explains its non-obvious fields.
 type LlmStructuredOutputProgrammer_IWriteProps struct {
   Context  nativecontext.ITypiaContext
   Modulo   *shimast.Node