Schema generator customisation

[bc-tayvs]

Is your feature request related to a problem? Please describe.
Provide a way to customize the schema generator.

Possible customizations include:

• Setting a default additionalProperties schema section.
• Adding a schema registry to provide manually created schemas for interfaces and structures with custom scalar types.

Currently, schemas generated for structures with interfaces cause schema-related errors on the MCP client side (e.g., inspector, cursor).

Describe the solution you'd like
infer.go file contains public method:

func For[T any]() (*Schema, error)

Introduce a new method that accepts customization options. For example:

type CustomisationOptions struct {
  additionalProperties *Schema
  schemaRegistry map[reflect.Type]*Schema
}

// Used for regular 'For' method
var defaultCustomisationOptions := CustomisationOptions {falseSchema(), make(map[reflect.Type]*Schema)}

func CustomisedFor[T any](options CustomisationOptions) (*Schema, error)

Describe alternatives you've considered
Helper methods to traverse generated schema and update it

Additional context
In our project, we use genqlient to generate methods and models based on a GraphQL schema and requests. GraphQL interfaces are represented in Go as struct types containing interface fields.

When generating schemas from such models, we encounter schemas with objects that lack fields and include additionalProperties: {not: {}}. This causes structuredContent validation to fail.

Allowing customization of the additionalProperties behavior would resolve these client-side validation errors.

[jba]

Could you adjust the schemas that you get after calling For[T]? It seems like you could write your own function to do that, without adding to the jsonschema package.

[bc-tayvs]

Could you adjust the schemas that you get after calling For[T]?

Yes, I believe it's possible. Though I think CustomisationOptions might be a starting point of making generator more extendable and customisable, allowing to cover more complicated use cases.

[jba]

Although you're right that we could cover more cases, we also want to keep things as simple as possible.

[bc-tayvs]

Update

Could you adjust the schemas that you get after calling For[T]

Tried possible implementation that does not required changes in For[T] function. Encountered problem of type erasing. In a generator we know a name of a struct/interface and we can provide modification for all type occurrences. In generated schema we have a field with type object (more tricky for arrays).

Potentially, it's possible to have a list of all field names that have interested for us type. In big query It will require many manual work what.

---

we also want to keep things as simple as possible.

Then we can approach the problem from another side and implement something simple yet universal.

Here is an another proposal
Lets split problem on two parts: interfaces and structs

Interfaces

Generator can not generate schema for an interfaces. So someone should do this (1) and somehow inject to the generator(2).

(1) Schema creation
Users can create a schema for interface by generating schemas for each possible ancestor and then combine them with some OneOf schema functionality. Helper method that takes types of ancestors and does all mentioned above might be pretty useful.

Something like

func InterfaceSchema(ancestors []reflect.Type)

(2) Schema injection
Using described originally structure like

type CustomisationOptions struct {
  ...
  InterfacesSchemaRegistry map[reflect.Type]*Schema
}

BUT schema registry only for interfaces

Structures

In my case, I just need to update AdditionalProperties but I also saw another issue where author want to use tags to infer more schema properties. Somebody may also want to use validation tags to infer another schema properties.

All this and more cases can be covered with 'post generation update'. Basically and update function and will be called after infering (q1 Can this function override generated Properties/Items?)

type UpdateFunc = func (schema *Schema) *Schema

Such functions can update just a portion of schema and can be chained together. Example of a function:

var UpdateAdditionalProperties = func (schema *Schema) *Schema {
  if schema == nil {
    return schema
  }
  schema.AdditionalProperties = &Schema{}
  return schema
}

In the similar way can be implemented custom tag parsing and much more

The updaters will also be in config and would look like this

type CustomisationOptions struct {
  ...
  UpdaterFactory func(reflect.Type) UpdateFunc // Used function and not a map to support default updater for all types
}

[jba]

I'm skeptical we can find a way forward for interfaces, but I'm open to trying.

each possible ancestor

But you can't know this list in advance. It's open-ended.

Share an example of how genqlient uses interfaces. Then we can have a more concrete discussion.

also saw another #140 where author want to use tags to infer more schema properties

At that point it's not really inference, it's just a shorthand for writing the code. In any case, that's orthogonal to this topic.

with 'post generation update'. Basically an update function and will be called after inferring

But this is the same as

schema, err := jsonschema.For[T]()
...
// your very own post generation update function

There's no need to add this feature to the jsonschema package.

[bc-tayvs]

But you can't know this list in advance. It's open-ended.
Share an example of how genqlient uses interfaces. Then we can have a more concrete discussion.

Technically the list is open ended but tool generates finite amount of implementations. But you are right, lets take a look at the examples.

I have created a dummy gql types. We are interested in Union type and Interface type.

# Union example
union Value = StringValue | IntValue

type StringValue {
    strValue: String!
}

type IntValue {
    intValue: Int!
}

# Interface example
interface Interface {
    field: String!
}
type A implements Interface {
    a: String!
    field: String!
}
type B implements Interface {
    b: String!
    field: String!
}

# Wrappers
type Wrapper1 {
    value: Value!
    interfaceValue: Interface!
}

A model for union type will look like this (not exactly the output of tool. simplified for clarity)

type Value interface { ... }

type IntValue struct { ...} // Implements the interface
type StringValue struct { ...} // Implements the interface

A model for interface type will look like this (not exactly the output of tool. simplified for clarity)

type Interface interface { ... }

type InterfaceValueA struct { ...} // Implements the interface
type InterfaceValueB struct { ...} // Implements the interface

And the Wrapper1

type Wrapper1 struct {
  Value Value // Interface type
  InterfaceValue Interface  // Interface type
}

So GQL's Union type and Interface generated as go interface. And possible options represented as structures that implements corresponding interface.
Because of that I was thinking about generation interface schema as OneOf of ancestors schemas

---

But this is the same as

schema, err := jsonschema.ForT
...
// your very own post generation update function
There's no need to add this feature to the jsonschema package.

what you proposing can be easily implemented if we talking about simple structure without nesting. Lets use GQL types from above and add few layers of wrappers

# Wrappers

type DummyObject {
  dummyInt: Int!
}

type Wrapper1 {
    value: Value!
    interfaceValue: Interface!
    dummyField: DummyObject!
}

type Wrapper2 {
    value: Wrapper1!
}

type Wrapper3 {
    value: Wrapper2!
}

# Query
type Query {
    value: Wrapper3!
}

So I want to generate a schema for Wrapper3 and I want to modify something in DummyObject schema. I don't have easy access to the schema of the Value and I also don't have information about what type was used to generate this part of schema. To traverse manually the schema after it generated, I would need a list of (jsonPath + reflect.Type + UpdaterFunc)

Updater function could be applied during schema generation for the Value type, removing necessity in traversing already generated schema.

---

whole schema

# Union example
union Value = StringValue | IntValue

type StringValue {
    strValue: String!
}

type IntValue {
    intValue: Int!
}

# Interface example
interface Interface {
    field: String!
}
type A implements Interface {
    a: String!
    field: String!
}
type B implements Interface {
    b: String!
    field: String!
}

# Wrappers
type Wrapper1 {
    value: Value!
    interfaceValue: Interface!
}

type Wrapper2 {
    value: Wrapper1!
}

type Wrapper3 {
    value: Wrapper2!
}

# Query
type Query {
    value: Wrapper3!
}

Graphql query

query Query{
    value {
        value {
            value {
                value {
                    ... on StringValue {
                        strValue
                    }
                    ... on IntValue {
                        intValue
                    }
                }
                interfaceValue {
                    ... on A {
                        a
                        field
                    }
                    ... on B {
                        b
                        field
                    }
                }
            }
        }
    }
}

Generated go code

// Code generated by github.com/Khan/genqlient, DO NOT EDIT.

package graphql

import (
	"context"
	"encoding/json"
	"fmt"

	"github.com/Khan/genqlient/graphql"
)

// QueryResponse is returned by Query on success.
type QueryResponse struct {
	Value QueryValueWrapper3 `json:"value"`
}

// GetValue returns QueryResponse.Value, and is useful for accessing the field via an interface.
func (v *QueryResponse) GetValue() QueryValueWrapper3 { return v.Value }

// QueryValueWrapper3 includes the requested fields of the GraphQL type Wrapper3.
type QueryValueWrapper3 struct {
	Value QueryValueWrapper3ValueWrapper2 `json:"value"`
}

// GetValue returns QueryValueWrapper3.Value, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3) GetValue() QueryValueWrapper3ValueWrapper2 { return v.Value }

// QueryValueWrapper3ValueWrapper2 includes the requested fields of the GraphQL type Wrapper2.
type QueryValueWrapper3ValueWrapper2 struct {
	Value QueryValueWrapper3ValueWrapper2ValueWrapper1 `json:"value"`
}

// GetValue returns QueryValueWrapper3ValueWrapper2.Value, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2) GetValue() QueryValueWrapper3ValueWrapper2ValueWrapper1 {
	return v.Value
}

// QueryValueWrapper3ValueWrapper2ValueWrapper1 includes the requested fields of the GraphQL type Wrapper1.
type QueryValueWrapper3ValueWrapper2ValueWrapper1 struct {
	Value          QueryValueWrapper3ValueWrapper2ValueWrapper1Value                   `json:"-"`
	InterfaceValue QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface `json:"-"`
}

// GetValue returns QueryValueWrapper3ValueWrapper2ValueWrapper1.Value, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1) GetValue() QueryValueWrapper3ValueWrapper2ValueWrapper1Value {
	return v.Value
}

// GetInterfaceValue returns QueryValueWrapper3ValueWrapper2ValueWrapper1.InterfaceValue, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1) GetInterfaceValue() QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface {
	return v.InterfaceValue
}

func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*QueryValueWrapper3ValueWrapper2ValueWrapper1
		Value          json.RawMessage `json:"value"`
		InterfaceValue json.RawMessage `json:"interfaceValue"`
		graphql.NoUnmarshalJSON
	}
	firstPass.QueryValueWrapper3ValueWrapper2ValueWrapper1 = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	{
		dst := &v.Value
		src := firstPass.Value
		if len(src) != 0 && string(src) != "null" {
			err = __unmarshalQueryValueWrapper3ValueWrapper2ValueWrapper1Value(
				src, dst)
			if err != nil {
				return fmt.Errorf(
					"unable to unmarshal QueryValueWrapper3ValueWrapper2ValueWrapper1.Value: %w", err)
			}
		}
	}

	{
		dst := &v.InterfaceValue
		src := firstPass.InterfaceValue
		if len(src) != 0 && string(src) != "null" {
			err = __unmarshalQueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface(
				src, dst)
			if err != nil {
				return fmt.Errorf(
					"unable to unmarshal QueryValueWrapper3ValueWrapper2ValueWrapper1.InterfaceValue: %w", err)
			}
		}
	}
	return nil
}

type __premarshalQueryValueWrapper3ValueWrapper2ValueWrapper1 struct {
	Value json.RawMessage `json:"value"`

	InterfaceValue json.RawMessage `json:"interfaceValue"`
}

func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1) MarshalJSON() ([]byte, error) {
	premarshaled, err := v.__premarshalJSON()
	if err != nil {
		return nil, err
	}
	return json.Marshal(premarshaled)
}

func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1) __premarshalJSON() (*__premarshalQueryValueWrapper3ValueWrapper2ValueWrapper1, error) {
	var retval __premarshalQueryValueWrapper3ValueWrapper2ValueWrapper1

	{

		dst := &retval.Value
		src := v.Value
		var err error
		*dst, err = __marshalQueryValueWrapper3ValueWrapper2ValueWrapper1Value(
			&src)
		if err != nil {
			return nil, fmt.Errorf(
				"unable to marshal QueryValueWrapper3ValueWrapper2ValueWrapper1.Value: %w", err)
		}
	}
	{

		dst := &retval.InterfaceValue
		src := v.InterfaceValue
		var err error
		*dst, err = __marshalQueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface(
			&src)
		if err != nil {
			return nil, fmt.Errorf(
				"unable to marshal QueryValueWrapper3ValueWrapper2ValueWrapper1.InterfaceValue: %w", err)
		}
	}
	return &retval, nil
}

// QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA includes the requested fields of the GraphQL type A.
type QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA struct {
	Typename *string `json:"__typename"`
	A        string  `json:"a"`
	Field    string  `json:"field"`
}

// GetTypename returns QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA.Typename, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA) GetTypename() *string {
	return v.Typename
}

// GetA returns QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA.A, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA) GetA() string { return v.A }

// GetField returns QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA.Field, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA) GetField() string {
	return v.Field
}

// QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB includes the requested fields of the GraphQL type B.
type QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB struct {
	Typename *string `json:"__typename"`
	B        string  `json:"b"`
	Field    string  `json:"field"`
}

// GetTypename returns QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB.Typename, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB) GetTypename() *string {
	return v.Typename
}

// GetB returns QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB.B, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB) GetB() string { return v.B }

// GetField returns QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB.Field, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB) GetField() string {
	return v.Field
}

// QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface includes the requested fields of the GraphQL interface Interface.
//
// QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface is implemented by the following types:
// QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA
// QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB
type QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface interface {
	implementsGraphQLInterfaceQueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface()
	// GetTypename returns the receiver's concrete GraphQL type-name (see interface doc for possible values).
	GetTypename() *string
}

func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA) implementsGraphQLInterfaceQueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface() {
}
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB) implementsGraphQLInterfaceQueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface() {
}

func __unmarshalQueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface(b []byte, v *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface) error {
	if string(b) == "null" {
		return nil
	}

	var tn struct {
		TypeName string `json:"__typename"`
	}
	err := json.Unmarshal(b, &tn)
	if err != nil {
		return err
	}

	switch tn.TypeName {
	case "A":
		*v = new(QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA)
		return json.Unmarshal(b, *v)
	case "B":
		*v = new(QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB)
		return json.Unmarshal(b, *v)
	case "":
		return fmt.Errorf(
			"response was missing Interface.__typename")
	default:
		return fmt.Errorf(
			`unexpected concrete type for QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface: "%v"`, tn.TypeName)
	}
}

func __marshalQueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface(v *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface) ([]byte, error) {

	var typename string
	switch v := (*v).(type) {
	case *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA:
		typename = "A"

		result := struct {
			TypeName string `json:"__typename"`
			*QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueA
		}{typename, v}
		return json.Marshal(result)
	case *QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB:
		typename = "B"

		result := struct {
			TypeName string `json:"__typename"`
			*QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueB
		}{typename, v}
		return json.Marshal(result)
	case nil:
		return []byte("null"), nil
	default:
		return nil, fmt.Errorf(
			`unexpected concrete type for QueryValueWrapper3ValueWrapper2ValueWrapper1InterfaceValueInterface: "%T"`, v)
	}
}

// QueryValueWrapper3ValueWrapper2ValueWrapper1Value includes the requested fields of the GraphQL interface Value.
//
// QueryValueWrapper3ValueWrapper2ValueWrapper1Value is implemented by the following types:
// QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue
// QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue
type QueryValueWrapper3ValueWrapper2ValueWrapper1Value interface {
	implementsGraphQLInterfaceQueryValueWrapper3ValueWrapper2ValueWrapper1Value()
	// GetTypename returns the receiver's concrete GraphQL type-name (see interface doc for possible values).
	GetTypename() *string
}

func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue) implementsGraphQLInterfaceQueryValueWrapper3ValueWrapper2ValueWrapper1Value() {
}
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue) implementsGraphQLInterfaceQueryValueWrapper3ValueWrapper2ValueWrapper1Value() {
}

func __unmarshalQueryValueWrapper3ValueWrapper2ValueWrapper1Value(b []byte, v *QueryValueWrapper3ValueWrapper2ValueWrapper1Value) error {
	if string(b) == "null" {
		return nil
	}

	var tn struct {
		TypeName string `json:"__typename"`
	}
	err := json.Unmarshal(b, &tn)
	if err != nil {
		return err
	}

	switch tn.TypeName {
	case "IntValue":
		*v = new(QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue)
		return json.Unmarshal(b, *v)
	case "StringValue":
		*v = new(QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue)
		return json.Unmarshal(b, *v)
	case "":
		return fmt.Errorf(
			"response was missing Value.__typename")
	default:
		return fmt.Errorf(
			`unexpected concrete type for QueryValueWrapper3ValueWrapper2ValueWrapper1Value: "%v"`, tn.TypeName)
	}
}

func __marshalQueryValueWrapper3ValueWrapper2ValueWrapper1Value(v *QueryValueWrapper3ValueWrapper2ValueWrapper1Value) ([]byte, error) {

	var typename string
	switch v := (*v).(type) {
	case *QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue:
		typename = "IntValue"

		result := struct {
			TypeName string `json:"__typename"`
			*QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue
		}{typename, v}
		return json.Marshal(result)
	case *QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue:
		typename = "StringValue"

		result := struct {
			TypeName string `json:"__typename"`
			*QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue
		}{typename, v}
		return json.Marshal(result)
	case nil:
		return []byte("null"), nil
	default:
		return nil, fmt.Errorf(
			`unexpected concrete type for QueryValueWrapper3ValueWrapper2ValueWrapper1Value: "%T"`, v)
	}
}

// QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue includes the requested fields of the GraphQL type IntValue.
type QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue struct {
	Typename *string `json:"__typename"`
	IntValue int     `json:"intValue"`
}

// GetTypename returns QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue.Typename, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue) GetTypename() *string {
	return v.Typename
}

// GetIntValue returns QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue.IntValue, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1ValueIntValue) GetIntValue() int {
	return v.IntValue
}

// QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue includes the requested fields of the GraphQL type StringValue.
type QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue struct {
	Typename *string `json:"__typename"`
	StrValue string  `json:"strValue"`
}

// GetTypename returns QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue.Typename, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue) GetTypename() *string {
	return v.Typename
}

// GetStrValue returns QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue.StrValue, and is useful for accessing the field via an interface.
func (v *QueryValueWrapper3ValueWrapper2ValueWrapper1ValueStringValue) GetStrValue() string {
	return v.StrValue
}

// The query executed by Query.
const Query_Operation = `
query Query {
	value {
		value {
			value {
				value {
					__typename
					... on StringValue {
						strValue
					}
					... on IntValue {
						intValue
					}
				}
				interfaceValue {
					__typename
					... on A {
						a
						field
					}
					... on B {
						b
						field
					}
				}
			}
		}
	}
}
`

func Query(
	ctx_ context.Context,
	client_ graphql.Client,
) (data_ *QueryResponse, err_ error) {
	req_ := &graphql.Request{
		OpName: "Query",
		Query:  Query_Operation,
	}

	data_ = &QueryResponse{}
	resp_ := &graphql.Response{Data: data_}

	err_ = client_.MakeRequest(
		ctx_,
		req_,
		resp_,
	)

	return data_, err_
}

[RoyceLeonD]

Here is my opinion, the MCP specification is clear: tools must provide an inputSchema that is "A JSON Schema object defining the expected parameters for the tool". The spec doesn't dictate HOW this schema should be generated - it just needs to be valid JSON Schema. A low-level SDK should do nothing more, but some customization is expected.

A low-level SDK should provide the minimal interface required by the spec, nothing more. Acknowledging that Go's reflection doesn't map cleanly to JSON Schema is ture- but that's why it is a default and not the only option. I think the schema generator should remain simple and spec-compliant, not grow into a configuration monster.
I believe this SDK should:

• Provide a solid default implementation that works for common cases, and is 100% aligned with the spec
• Allow users to completely bypass/replace schema generation when needed

As an SDK we should keep the core minimal yet extendible; Adding configuration options to work around edge cases is a slippery slope. Today it's GraphQL interfaces, tomorrow it's protobuf oneofs, next week it's custom tags. This belongs in higher-level frameworks, not the core SDK.

@bc-tayvs Instead of CustomisedFor with additional parameters, we should think about how mcp.Schema() can bypass schema generation.

Someone, tell me if this even makes sense:

mcp.AddTool(server, &mcp.Tool{
    Name: "process_data",
    Description: "Process data", 
}, ProcessData, mcp.Schema(&jsonschema.Schema{
    Type: "object",
    Properties: map[string]*jsonschema.Schema{
        // Your custom schema here
    },
}))

I personally don't like the schema modification in since it still forces you to utilize pices that you may not care about.

&jsonschema.Schema{
        // schema modifications
    }

What would be nice to see is a way to completely replace schema. For GraphQL specifically: you could then generate schemas alongside your GraphQL code generation? Your codegen already understands the types - have it output both Go structs AND their corresponding JSON schemas. This keeps the complexity where it belongs: in your build process, not runtime reflection. And then in the SDK a rawJsonSchema might be useful, it might create complexities in validation but it could be a give-and-take

@bc-tayvs What I think would be valuable in this proposal is not just add custom configurations on the current generator, but the capability to truly allow custom generators and validators.

[jba]

I tend to agree with @RoyceLeonD: we shouldn't complicate the jsonschema package for all use cases.

One change that seems reasonable is to have For[T] ignore types it doesn't understand instead of returning an error. Then you could run it first, and fill in the missing parts on your own. I'll work on that now (pretty simple).

I think you have two strategies: one is as Royce said, to modify the generator, since it already understands Go types. The other is to write your own reflection-based code. If you look at For[T] and its helper in https://github.com/modelcontextprotocol/go-sdk/blob/main/jsonschema/infer.go, you'll see it's only about 120 lines of code. You could get by with much less, since you only care about the interface case. Writing reflection code is tricky, I admit, but I'd be happy to assist.

[jba]

So in that PR (#147) I actually added a second function ForLax, that ignores invalid types instead of returning an error.