fix(openapi): carry nullability onto the top-level scalar schema

The scalar branch emitted the type alone, so a `static properties` field
declared `{ type: 'string', nullable: true }` (or `['string','null']`, which
folds to the same attribute) produced a document asserting the field rejects
null — while MCP kept it nullable. The nested/array paths already translated
this through toOpenApiDialect; only the top-level path did not.

Also intersects `const` with a co-declared `enum` rather than deferring to the
enum, matching the nested path.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0188G62J9fZQg4J9rVuqLzjy

Author: nizzlenitz

resources/openApi.ts

@@ -251,12 +251,27 @@ export function generateJsonApi(resources: Resources, serverHttpURL: string) {
 				// subset: `const` only arrived in draft-06, so it is not a keyword here. Emit the
 				// equivalent single-value `enum` instead of a keyword the declared dialect doesn't define.
 				if (props[name] && typeof props[name] === 'object' && !('$ref' in props[name])) {
-					const prop = props[name] as { description?: string; enum?: unknown; format?: string };
+					const prop = props[name] as {
+						description?: string;
+						enum?: unknown[];
+						format?: string;
+						nullable?: boolean;
+					};
 					if (description) prop.description = description;
 					if (attr.enum && prop.enum === undefined) prop.enum = attr.enum;
 					// An author-declared `format` outranks the Harper type name `Type()` stamps on.
 					if (attr.format) prop.format = attr.format;
-					if (attr.const !== undefined && prop.enum === undefined) prop.enum = [attr.const];
+					// Intersect rather than defer: `const` narrows an `enum` declared alongside it.
+					if (attr.const !== undefined) {
+						prop.enum = Array.isArray(prop.enum) ? prop.enum.filter((value) => value === attr.const) : [attr.const];
+					}
+					// `type: ['string', 'null']` folds to `type: 'string'` + `nullable` upstream; without this the
+					// scalar path emits the type alone and the document claims the field rejects null.
+					if (nullable) prop.nullable = true;
+					// 3.0's `nullable` does not widen an `enum` — without `null` in the list a validator rejects it.
+					if (prop.nullable && Array.isArray(prop.enum) && !prop.enum.includes(null)) {
+						prop.enum = [...prop.enum, null];
+					}
 				}
 				queryParamsArray.push(new Parameter(name, 'query', props[name]));
 			}

unitTests/resources/openApi.test.js

@@ -419,6 +419,22 @@ describe('openApi — declared dialect compliance (3.0.3)', () => {
 		expect(props.kind).to.not.have.property('const');
 	});
 
+	it('carries nullability onto the emitted scalar schema', () => {
+		// The walk assertions above only prove `type: 'null'` and unions are gone; they would pass just as
+		// happily if nullability were dropped instead of translated.
+		const props = buildDocument().components.schemas.Widget.properties;
+		expect(props.maybe).to.deep.equal({ type: 'string', nullable: true });
+		expect(props.nothing.nullable).to.equal(true);
+	});
+
+	it('widens a nullable `enum` with `null` (3.0 `nullable` does not do it)', () => {
+		const props = buildDocument().components.schemas.Widget.properties;
+		expect(props.nullableEnum.nullable).to.equal(true);
+		expect(props.nullableEnum.enum).to.deep.equal(['a', 'b', null]);
+		// `const` + `nullable`: the single-value enum still has to admit null.
+		expect(props.nullableConst.enum).to.deep.equal(['fixed', null]);
+	});
+
 	it('emits the properties under test (guards the walk assertions against an empty document)', () => {
 		const props = buildDocument().components.schemas.Widget.properties;
 		for (const key of ['kind', 'nothing', 'maybe', 'nested', 'list', 'nullableEnum', 'nullableConst', 'when']) {