fix(inventory): gate typed output on supported protocol range

Select modern typed output for SDK-supported ISO-date protocol versions from 2026-07-28 onward. Missing, malformed, and unsupported future versions retain legacy behavior. Cover a later supported version through the selector list seam and verify the public path against the SDK supported set.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: SamMorrowDrums

docs/typed-tool-schemas.md

@@ -43,9 +43,10 @@ subschemas. Default removal visits each child once per parent. The advertised
 schema can retain its defaults; the constructor caches the runtime schema
 without mutating either caller-owned schema.
 
-The output schema and `structuredContent` are exposed only for the exact
-protocol version `2026-07-28`. Older, absent, and unrecognized versions retain
-the legacy text result. Normal `Inventory.RegisterTools` and
+The output schema and `structuredContent` are exposed only for a negotiated,
+SDK-supported protocol version `2026-07-28` or later. Unknown versions are
+treated as legacy, including unsupported future dates; older, absent, and
+malformed versions also retain the legacy text result. Normal `Inventory.RegisterTools` and
 `ServerTool.RegisterFunc` registrations select behavior per request. Use
 `RegisterToolsForProtocolEra` or `RegisterFuncForProtocolEra` only when the
 protocol era is already known before server construction, such as a stateless

pkg/inventory/typed_output_test.go

@@ -171,6 +171,40 @@ func TestCachedExplicitSchemaWarmPathsPreserveOwnership(t *testing.T) {
 	assert.Zero(t, allocations, "cache-owned warm schemas must avoid canonical serialization and annotation cloning")
 }
 
+func TestProtocolEraForSupportedVersions(t *testing.T) {
+	supported := []string{"2027-01-01", ProtocolVersionMultiRoundTrip, "2025-11-25", "2027-02-30", "garbage"}
+	for _, tc := range []struct {
+		name    string
+		version string
+		want    ProtocolEra
+	}{
+		{name: "exact threshold", version: ProtocolVersionMultiRoundTrip, want: ProtocolEraModern},
+		{name: "supported later", version: "2027-01-01", want: ProtocolEraModern},
+		{name: "older", version: "2025-11-25", want: ProtocolEraLegacy},
+		{name: "unsupported future", version: "2099-01-01", want: ProtocolEraLegacy},
+		{name: "invalid date even if listed", version: "2027-02-30", want: ProtocolEraLegacy},
+		{name: "garbage even if listed", version: "garbage", want: ProtocolEraLegacy},
+		{name: "absent", want: ProtocolEraLegacy},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			assert.Equal(t, tc.want, protocolEraForSupportedVersion(tc.version, supported))
+		})
+	}
+	assert.Equal(t, ProtocolEraLegacy, protocolEraForSupportedVersion(ProtocolVersionMultiRoundTrip, nil),
+		"a valid modern date must still be supported")
+
+	for _, version := range mcp.SupportedProtocolVersions() {
+		want := ProtocolEraLegacy
+		if version >= ProtocolVersionMultiRoundTrip {
+			want = ProtocolEraModern
+		}
+		assert.Equal(t, want, ProtocolEraForVersion(version), "SDK-supported version %q", version)
+	}
+	for _, version := range []string{"", "garbage", "2027-02-30", "2099-01-01"} {
+		assert.Equal(t, ProtocolEraLegacy, ProtocolEraForVersion(version), "unknown version %q", version)
+	}
+}
+
 func TestCachedSchemaDeepCopiesMutableMetadata(t *testing.T) {
 	constant := any(map[string]any{"nested": []string{"const"}})
 	nullConstant := any(nil)

pkg/inventory/typed_schema.go

@@ -9,6 +9,7 @@ import (
 	"sort"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
@@ -26,13 +27,20 @@ const (
 	ProtocolEraModern
 )
 
-// ProtocolEraForVersion selects modern behavior only for the exact supported
-// version. Unknown and future versions remain on the legacy contract.
+// ProtocolEraForVersion selects modern behavior for SDK-supported protocol
+// versions from 2026-07-28 onward. Unknown versions remain legacy.
 func ProtocolEraForVersion(version string) ProtocolEra {
-	if version == ProtocolVersionMultiRoundTrip {
-		return ProtocolEraModern
+	return protocolEraForSupportedVersion(version, mcp.SupportedProtocolVersions())
+}
+
+func protocolEraForSupportedVersion(version string, supported []string) ProtocolEra {
+	if _, err := time.Parse(time.DateOnly, version); err != nil {
+		return ProtocolEraLegacy
+	}
+	if version < ProtocolVersionMultiRoundTrip || !slices.Contains(supported, version) {
+		return ProtocolEraLegacy
 	}
-	return ProtocolEraLegacy
+	return ProtocolEraModern
 }
 
 // SchemaEnum adds an enum to a property of an inferred schema. Path is a