Add support for open discriminators in JSON Schema emitter (#9127)

## Summary

Adds support for **open discriminators** in the JSON Schema emitter.
When a discriminator type includes `string` (indicating it can accept
values beyond the explicitly defined ones), the emitter now generates a
catch-all variant that validates unknown discriminator values against
the base model schema. This applies only when using the
`polymorphic-models-strategy` option as it is intended for validating
discriminated unions.

## Problem

When defining a discriminated union with an "open" discriminator like:

```typespec
union ToolType {
  string,
  file_search: "file_search",
  function: "function",
}

@Discriminator("type")
model Tool {
  type: ToolType;
}

model FileSearchTool extends Tool {
  type: ToolType.file_search;
}

model FunctionTool extends Tool {
  type: ToolType.function;
}
```

The previous behavior would only generate oneOf variants for the known
types (file_search, function), causing validation to fail for any
unknown tool types - even though the string in the union indicates they
should be allowed.

## Solution

When the discriminator type includes string, the emitter now generates a
catch-all variant:

```typespec
{
  "type": "object",
  "properties": {
    "type": {
      "type": "string",
      "not": {
        "enum": ["file_search", "function"]
      }
    }
  },
  "required": ["type"]
}
```

The catch all:
- Matches any discriminator value not in the known set
- Validates against the base model schema only
- Preserves full type checking for known discriminator values

## Testing
Added 3 test cases:
- Open discriminator with type: string - expects catch-all variant
- Open discriminator with union containing string variant - expects
catch-all variant
- Closed discriminator (no string in union) - expects no catch-all
variant (negative test)

Co-authored-by: Michael Taylor <mictaylor@microsoft.com>

Author: mike-taylor99

.chronus/changes/mictaylor-json-schema-open-discriminator-support-2025-11-2-20-20-32.md

@@ -0,0 +1,7 @@
+---
+changeKind: internal
+packages:
+  - "@typespec/json-schema"
+---
+
+add support for open discriminators

packages/json-schema/src/json-schema-emitter.ts

@@ -51,6 +51,7 @@ import {
   getPattern,
   getRelativePathFromDirectory,
   getSummary,
+  isStringType,
   isType,
   joinPaths,
   serializeValueAsJson,
@@ -776,14 +777,30 @@ export class JsonSchemaEmitter extends TypeEmitter<Record<string, any>, JSONSche
     strategy: "oneOf" | "anyOf",
   ): EmitterOutput<object> {
     const variants = new ArrayBuilder<Record<string, unknown>>();
+    const knownDiscriminatorValues: string[] = [];
 
-    // Collect all derived models
+    // Collect all derived models and their discriminator values
     for (const derived of model.derivedModels) {
       if (!includeDerivedModel(derived)) continue;
 
       // Add reference to each derived model
       const derivedRef = this.emitter.emitTypeReference(derived);
       variants.push(derivedRef);
+
+      // Collect discriminator values for catch-all generation
+      const values = this.#getDiscriminatorValues(derived, discriminator.propertyName);
+      knownDiscriminatorValues.push(...values);
+    }
+
+    // Check if this is an open discriminator (discriminator property type includes string)
+    // If so, add a catch-all variant that matches any unknown discriminator value
+    if (this.#isOpenDiscriminator(model, discriminator.propertyName)) {
+      const catchAllVariant = this.#createCatchAllVariant(
+        model,
+        discriminator.propertyName,
+        knownDiscriminatorValues,
+      );
+      variants.push(catchAllVariant);
     }
 
     // For discriminated unions, emit the oneOf/anyOf with base model properties
@@ -800,6 +817,109 @@ export class JsonSchemaEmitter extends TypeEmitter<Record<string, any>, JSONSche
     return this.#createDeclaration(model, name, schema);
   }
 
+  /**
+   * Check if the discriminator property type is "open" (includes the string scalar type).
+   * This means the discriminated union can accept unknown discriminator values.
+   */
+  #isOpenDiscriminator(model: Model, discriminatorPropertyName: string): boolean {
+    const prop = model.properties.get(discriminatorPropertyName);
+    if (!prop) return false;
+
+    return this.#typeIncludesString(prop.type);
+  }
+
+  /**
+   * Check if a type includes the string scalar (not just string literals).
+   */
+  #typeIncludesString(type: Type): boolean {
+    const program = this.emitter.getProgram();
+
+    switch (type.kind) {
+      case "Scalar":
+        return isStringType(program, type);
+      case "Union":
+        // Check if any variant is the string scalar
+        for (const variant of type.variants.values()) {
+          if (this.#typeIncludesString(variant.type)) {
+            return true;
+          }
+        }
+        return false;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Get string discriminator values from a model's discriminator property.
+   */
+  #getDiscriminatorValues(model: Model, discriminatorPropertyName: string): string[] {
+    const prop = model.properties.get(discriminatorPropertyName);
+    if (!prop) return [];
+
+    return this.#getStringLiteralValues(prop.type);
+  }
+
+  /**
+   * Extract string literal values from a type.
+   */
+  #getStringLiteralValues(type: Type): string[] {
+    switch (type.kind) {
+      case "String":
+        return [type.value];
+      case "Union":
+        return [...type.variants.values()].flatMap((v) => this.#getStringLiteralValues(v.type));
+      case "UnionVariant":
+        return this.#getStringLiteralValues(type.type);
+      case "EnumMember":
+        return typeof type.value !== "number" ? [type.value ?? type.name] : [];
+      default:
+        return [];
+    }
+  }
+
+  /**
+   * Create a catch-all variant for open discriminated unions.
+   * This variant matches any discriminator value not in the known values.
+   */
+  #createCatchAllVariant(
+    model: Model,
+    discriminatorPropertyName: string,
+    knownValues: string[],
+  ): Record<string, unknown> {
+    const properties = new ObjectBuilder();
+
+    // Emit all base model properties
+    for (const [propName, prop] of model.properties) {
+      if (propName === discriminatorPropertyName) {
+        // Override discriminator property to match any string NOT in known values
+        setProperty(properties, propName, {
+          type: "string",
+          not: { enum: knownValues },
+        });
+      } else {
+        const result = this.emitter.emitModelProperty(prop);
+        setProperty(properties, propName, result);
+      }
+    }
+
+    // If discriminator property is not explicitly defined, add it
+    if (!model.properties.has(discriminatorPropertyName)) {
+      setProperty(properties, discriminatorPropertyName, {
+        type: "string",
+        not: { enum: knownValues },
+      });
+    }
+
+    const required = this.#requiredModelProperties(model);
+
+    return {
+      type: "object",
+      properties: properties,
+      ...(required && { required }),
+    };
+  }
+
   intrinsic(intrinsic: IntrinsicType, name: string): EmitterOutput<object> {
     switch (intrinsic.name) {
       case "null":

packages/json-schema/test/discriminator.test.ts

@@ -467,4 +467,148 @@ describe("discriminated union with polymorphic-models-strategy option", () => {
     deepStrictEqual(petSchema.oneOf[0], { $ref: "#/$defs/Cat" });
     deepStrictEqual(petSchema.oneOf[1], { $ref: "#/$defs/Dog" });
   });
+
+  it("generates catch-all variant for open discriminators", async () => {
+    const schemas = await emitSchema(
+      `
+        @discriminator("type")
+        model Tool {
+          name: string;
+          type: string;
+        }
+
+        model FileSearch extends Tool {
+          type: "file_search";
+          query: string;
+        }
+
+        model Function extends Tool {
+          type: "function";
+          functionName: string;
+        }
+      `,
+      { "polymorphic-models-strategy": "oneOf" },
+    );
+
+    const toolSchema = schemas["Tool.json"];
+    ok(toolSchema, "Tool schema should exist");
+    ok(toolSchema.oneOf, "Tool schema should have oneOf");
+
+    // Should have 3 variants: 2 known types + 1 catch-all
+    strictEqual(toolSchema.oneOf.length, 3, "oneOf should have 3 options (2 known + catch-all)");
+
+    // First two should be references to known types
+    deepStrictEqual(toolSchema.oneOf[0], { $ref: "FileSearch.json" });
+    deepStrictEqual(toolSchema.oneOf[1], { $ref: "Function.json" });
+
+    // Third should be the catch-all variant
+    const catchAll = toolSchema.oneOf[2];
+    ok(catchAll, "Catch-all variant should exist");
+    strictEqual(catchAll.type, "object");
+    ok(catchAll.properties, "Catch-all should have properties");
+
+    // Catch-all discriminator property should have "not: { enum: [...known values...] }"
+    const typeProperty = catchAll.properties.type;
+    ok(typeProperty, "Catch-all should have type property");
+    strictEqual(typeProperty.type, "string");
+    ok(typeProperty.not, "Type property should have 'not' constraint");
+    deepStrictEqual(
+      typeProperty.not.enum,
+      ["file_search", "function"],
+      "Should exclude known values",
+    );
+
+    // Should include base properties
+    ok(catchAll.properties.name, "Catch-all should have name property");
+    deepStrictEqual(catchAll.required, ["name", "type"]);
+  });
+
+  it("generates catch-all variant for union discriminators that include string", async () => {
+    const schemas = await emitSchema(
+      `
+        union ToolType {
+          string,
+          file_search: "file_search",
+          function: "function",
+        }
+
+        @discriminator("type")
+        model Tool {
+          name: string;
+          type: ToolType;
+        }
+
+        model FileSearch extends Tool {
+          type: ToolType.file_search;
+          query: string;
+        }
+
+        model Function extends Tool {
+          type: ToolType.function;
+          functionName: string;
+        }
+      `,
+      { "polymorphic-models-strategy": "oneOf" },
+    );
+
+    const toolSchema = schemas["Tool.json"];
+    ok(toolSchema, "Tool schema should exist");
+    ok(toolSchema.oneOf, "Tool schema should have oneOf");
+
+    // Should have 3 variants: 2 known types + 1 catch-all
+    strictEqual(toolSchema.oneOf.length, 3, "oneOf should have 3 options (2 known + catch-all)");
+
+    // Third should be the catch-all variant
+    const catchAll = toolSchema.oneOf[2];
+    ok(catchAll, "Catch-all variant should exist");
+    strictEqual(catchAll.type, "object");
+
+    // Catch-all discriminator property should exclude known values
+    const typeProperty = catchAll.properties.type;
+    ok(typeProperty.not, "Type property should have 'not' constraint");
+    deepStrictEqual(
+      typeProperty.not.enum,
+      ["file_search", "function"],
+      "Should exclude known values",
+    );
+  });
+
+  it("does not generate catch-all for closed discriminators", async () => {
+    const schemas = await emitSchema(
+      `
+        union PetKind {
+          cat: "cat",
+          dog: "dog",
+        }
+
+        @discriminator("kind")
+        model Pet {
+          name: string;
+          kind: PetKind;
+        }
+
+        model Cat extends Pet {
+          kind: PetKind.cat;
+          meow: int32;
+        }
+
+        model Dog extends Pet {
+          kind: PetKind.dog;
+          bark: string;
+        }
+      `,
+      { "polymorphic-models-strategy": "oneOf" },
+    );
+
+    const petSchema = schemas["Pet.json"];
+    ok(petSchema, "Pet schema should exist");
+    ok(petSchema.oneOf, "Pet schema should have oneOf");
+
+    // Should have only 2 variants (no catch-all for closed union)
+    strictEqual(petSchema.oneOf.length, 2, "oneOf should have 2 options (no catch-all)");
+
+    // Both should be references to known types
+    deepStrictEqual(petSchema.oneOf[0], { $ref: "Cat.json" });
+    deepStrictEqual(petSchema.oneOf[1], { $ref: "Dog.json" });
+  });
 });