validating structs directly doesn't work

[jba]

Validation attempts to work on Go structs directly. But I think this is doomed:

• We would need to interpret some json struct tags (see validation on structs should handle required #22)
• Worse, we need to somehow understand custom marshalers (types that implement json.Marshaler).

I believe the only general solution is to marshal the struct to JSON before validating.

I think we can still validate non-structs directly.

[jba]

/cc @findleyr WDYT?

[findleyr]

@jba I assume you noted that I switch the Go SDK to marshal to/from JSON when validating.
Yes, I agree that it is doomed, in general. The only thing we could do is validate as we marshal/unmarshal, but that would require duplicating the encoding/json library.

[findleyr]

modelcontextprotocol/go-sdk#454, for the record.

[jba]

@findleyr if this package handles marshaling of structs, then we can remove code from the MCP SDK, right?
Is it wasteful for this package to marshal for validation and then throw away the JSON?
If so, maybe this package just shouldn't support Go values at all: Resolved.Validate should accept only map[string]any for type "object".

[findleyr]

FWIW, I've been load testing with ~reasonable schemas, and I wouldn't worry too much about the 3x extra marshalling. For example, here's a profile from applySchema.

         .       20ms     83:           v := make(map[string]any)
         .          .     84:           if len(data) > 0 {
         .      2.21s     85:                   if err := json.Unmarshal(data, &v); err != nil {
         .          .     86:                           return nil, fmt.Errorf("unmarshaling arguments: %w", err)
         .          .     87:                   }
         .          .     88:           }
         .      210ms     89:           if err := resolved.ApplyDefaults(&v); err != nil {
         .          .     90:                   return nil, fmt.Errorf("applying schema defaults:\n%w", err)
         .          .     91:           }
         .      6.08s     92:           if err := resolved.Validate(&v); err != nil {
         .          .     93:                   return nil, err
         .          .     94:           }
         .          .     95:           // We must re-marshal with the default values applied.
         .          .     96:           var err error
      20ms      1.69s     97:           data, err = json.Marshal(v)

Yes, the extra unmarshalling is costly, but only about 40% of applyDefaults, whereas validation is 60% (much more before a pending optimization that's included in this benchmark result (#25)).

So, I think it's safe to say that we could probably make validation ~3-4x faster by writing a huge amount of reflection and optimizing validation, but it's probably not significantly worthwhile.

[jba]

I'm going to fail if Validate is passed a struct.
We can put this back later if we want.