python: decode boolean-discriminated unions

The Python generator captured a union discriminator's JSON Schema `const`
with `String()`, so a boolean const became the string "true"/"false" and the
emitted dispatcher matched `case "true":`. A JSON boolean decodes to Python
`True`, which never equals `"true"`, so every boolean-discriminated union
fell through to `raise ValueError`.

Two unions are affected. `sessions.list()` raised
`ValueError: Unknown SessionListEntry isRemote: False` for any non-empty
session list, and `QueuedCommandHandled.to_dict()` put the string `"true"` on
the wire where the schema declares `{"type": "boolean", "const": true}`.

Keep the const's JSON type through codegen and render it as a Python literal
(`True`/`False`), annotating the discriminator `ClassVar` as `bool`. This
mirrors how `go.ts` already models discriminator values. Regenerating changes
six lines of `python/copilot/generated/rpc.py`; no other language changes.

Author: examon

python/copilot/generated/rpc.py

@@ -1,12 +1,21 @@
 """Tests for generated RPC method behavior."""
 
+import json
 from unittest.mock import AsyncMock
 
 import pytest
 
 from copilot.rpc import (
     CommandsApi,
     CommandsInvokeRequest,
+    CommandsRespondToQueuedCommandRequest,
+    LocalSessionMetadataValue,
+    QueuedCommandHandled,
+    QueuedCommandNotHandled,
+    RemoteControlStatusOff,
+    RemoteControlStatusResult,
+    RemoteSessionMetadataValue,
+    SessionList,
     SlashCommandTextResult,
 )
 
@@ -22,3 +31,77 @@ async def test_commands_invoke_deserializes_slash_command_result():
     assert isinstance(result, SlashCommandTextResult)
     assert result.text == "hello"
     assert result.markdown is True
+
+
+def test_remote_control_status_deserializes_string_discriminated_union():
+    result = RemoteControlStatusResult.from_dict({"status": {"state": "off"}})
+
+    assert isinstance(result.status, RemoteControlStatusOff)
+    assert result.status.state == "off"
+    assert result.status.to_dict() == {"state": "off"}
+
+
+def test_session_list_deserializes_boolean_discriminated_entries():
+    payload = {
+        "sessions": [
+            {
+                "sessionId": "example-local",
+                "startTime": "2026-07-26T10:00:00.000Z",
+                "modifiedTime": "2026-07-26T10:05:00.000Z",
+                "isRemote": False,
+            },
+            {
+                "sessionId": "example-remote",
+                "startTime": "2026-07-26T11:00:00.000Z",
+                "modifiedTime": "2026-07-26T11:05:00.000Z",
+                "isRemote": True,
+                "remoteSessionIds": ["example-remote"],
+                "repository": {"owner": "github", "name": "copilot-sdk", "branch": "main"},
+            },
+        ]
+    }
+
+    result = SessionList.from_dict(payload)
+
+    local, remote = result.sessions
+    assert isinstance(local, LocalSessionMetadataValue)
+    assert local.session_id == "example-local"
+    assert local.is_remote is False
+    assert isinstance(remote, RemoteSessionMetadataValue)
+    assert remote.session_id == "example-remote"
+    assert remote.is_remote is True
+    assert remote.repository.owner == "github"
+
+
+@pytest.mark.parametrize(
+    ("handled", "expected_type"),
+    [(True, QueuedCommandHandled), (False, QueuedCommandNotHandled)],
+)
+def test_queued_command_result_deserializes_boolean_discriminator(handled, expected_type):
+    request = CommandsRespondToQueuedCommandRequest.from_dict(
+        {"requestId": "example-request", "result": {"handled": handled}}
+    )
+
+    assert isinstance(request.result, expected_type)
+
+
+@pytest.mark.parametrize(
+    ("variant", "expected_handled", "expected_json"),
+    [
+        (QueuedCommandHandled(), True, '{"handled": true}'),
+        (QueuedCommandNotHandled(), False, '{"handled": false}'),
+    ],
+)
+def test_queued_command_result_serializes_boolean_discriminator(
+    variant, expected_handled, expected_json
+):
+    encoded = variant.to_dict()
+
+    assert encoded["handled"] is expected_handled
+    assert json.dumps(encoded) == expected_json
+
+    request = CommandsRespondToQueuedCommandRequest(request_id="example-request", result=variant)
+    round_tripped = CommandsRespondToQueuedCommandRequest.from_dict(request.to_dict())
+
+    assert request.to_dict()["result"]["handled"] is expected_handled
+    assert isinstance(round_tripped.result, type(variant))

python/test_rpc_generated.py

@@ -272,6 +272,39 @@ function postProcessExternalUnionAliasesForPython(code: string, aliases: Map<str
     return code.replace(/\n{3,}/g, "\n\n");
 }
 
+/**
+ * Literal value of a union discriminator. The API schema discriminates on
+ * string `const`s (`kind: "text"`) and on boolean ones
+ * (`SessionListEntry.isRemote`, `QueuedCommandResult.handled`), so the JSON
+ * type has to survive codegen: coercing `true` to `"true"` emits a dispatcher
+ * arm that the decoded Python `True` can never match. Mirrors
+ * `GoDiscriminatorValue` in `go.ts`.
+ */
+type PyDiscriminatorValue = string | boolean;
+
+/**
+ * Capture a schema `const` as a discriminator value, keeping booleans as
+ * booleans and stringifying everything else.
+ */
+function pyDiscriminatorValue(constValue: unknown): PyDiscriminatorValue {
+    return typeof constValue === "boolean" ? constValue : String(constValue);
+}
+
+/**
+ * Render a discriminator value as a Python literal. Booleans need Python's
+ * `True` / `False` spelling, since the JSON `true` would parse as a capture
+ * pattern in a `match` arm rather than as a literal.
+ */
+function pyDiscriminatorValueExpr(value: PyDiscriminatorValue): string {
+    if (typeof value === "boolean") return value ? "True" : "False";
+    return JSON.stringify(value);
+}
+
+/** Python type of a discriminator constant, for its `ClassVar` annotation. */
+function pyDiscriminatorValueType(value: PyDiscriminatorValue): string {
+    return typeof value === "boolean" ? "bool" : "str";
+}
+
 /**
  * Replace flat-merged dataclasses emitted by quicktype for $ref-based
  * discriminated unions with proper Python unions: a `Name = VariantA | ...`
@@ -293,7 +326,7 @@ function postProcessExternalUnionAliasesForPython(code: string, aliases: Map<str
 interface ResolvedRefBasedUnion {
     aliasName: string;
     discriminatorProp: string;
-    dispatch: Array<{ value: string; typeName: string }>;
+    dispatch: Array<{ value: PyDiscriminatorValue; typeName: string }>;
 }
 function postProcessRefBasedDiscriminatedUnionsForPython(
     code: string,
@@ -304,7 +337,7 @@ function postProcessRefBasedDiscriminatedUnionsForPython(
         aliasName: string;
         variantNames: string[];
         discriminatorProp: string;
-        dispatch: Array<{ value: string; typeName: string }>;
+        dispatch: Array<{ value: PyDiscriminatorValue; typeName: string }>;
         description: string | undefined;
     }
     const unions: UnionInfo[] = [];
@@ -334,7 +367,7 @@ function postProcessRefBasedDiscriminatedUnionsForPython(
                 discriminator.property
             ];
             return {
-                value: String(discProp.const),
+                value: pyDiscriminatorValue(discProp.const),
                 typeName: toPascalCase(variantRefNames[i]),
             };
         });
@@ -387,7 +420,7 @@ function postProcessRefBasedDiscriminatedUnionsForPython(
     for (const union of unions) {
         const actualAliasName = resolveActualName(union.aliasName);
         const actualVariantNames: string[] = [];
-        const actualDispatch: Array<{ value: string; typeName: string }> = [];
+        const actualDispatch: Array<{ value: PyDiscriminatorValue; typeName: string }> = [];
         let allResolved = true;
         for (let i = 0; i < union.variantNames.length; i++) {
             const actual = resolveActualName(union.variantNames[i]);
@@ -450,7 +483,7 @@ function postProcessRefBasedDiscriminatedUnionsForPython(
         dispatcherLines.push(`    kind = obj.get(${JSON.stringify(union.discriminatorProp)})`);
         dispatcherLines.push(`    match kind:`);
         for (const m of actualDispatch) {
-            dispatcherLines.push(`        case ${JSON.stringify(m.value)}: return ${m.typeName}.from_dict(obj)`);
+            dispatcherLines.push(`        case ${pyDiscriminatorValueExpr(m.value)}: return ${m.typeName}.from_dict(obj)`);
         }
         dispatcherLines.push(
             `        case _: raise ValueError(f"Unknown ${actualAliasName} ${union.discriminatorProp}: {kind!r}")`
@@ -500,7 +533,7 @@ function postProcessDiscriminatorDefaultsForPython(
     unions: ResolvedRefBasedUnion[]
 ): string {
     // Build variant lookup: variant class name → { prop, value }.
-    const variantInfo = new Map<string, { prop: string; value: string }>();
+    const variantInfo = new Map<string, { prop: string; value: PyDiscriminatorValue }>();
     for (const union of unions) {
         for (const d of union.dispatch) {
             // First-wins; multiple unions referencing the same variant share a
@@ -571,9 +604,9 @@ function postProcessDiscriminatorDefaultsForPython(
             continue;
         }
         const fieldIndent = (block[fieldIdx].match(/^(\s+)/) ?? ["", ""])[1];
-        const literal = JSON.stringify(info.value);
+        const literal = pyDiscriminatorValueExpr(info.value);
         // Replace the field with a class-level constant.
-        block[fieldIdx] = `${fieldIndent}${info.prop}: ClassVar[str] = ${literal}`;
+        block[fieldIdx] = `${fieldIndent}${info.prop}: ClassVar[${pyDiscriminatorValueType(info.value)}] = ${literal}`;
         usedClassVar = true;
 
         // Drop any field-trailing docstring lines that immediately followed the
@@ -1590,7 +1623,7 @@ function tryEmitPyRefBasedDiscriminatedUnion(
     if (!discriminator) return undefined;
 
     const variantTypeNames: string[] = [];
-    const dispatch: Array<{ value: string; typeName: string }> = [];
+    const dispatch: Array<{ value: PyDiscriminatorValue; typeName: string }> = [];
     for (let i = 0; i < variants.length; i++) {
         const variantTypeName = toPascalCase(variantRefNames[i]);
         const variantSchema = resolveObjectSchema(variants[i], ctx.definitions);
@@ -1599,7 +1632,7 @@ function tryEmitPyRefBasedDiscriminatedUnion(
         }
         variantTypeNames.push(variantTypeName);
         const discProp = resolvedVariants[i].properties?.[discriminator.property] as JSONSchema7;
-        dispatch.push({ value: String(discProp.const), typeName: variantTypeName });
+        dispatch.push({ value: pyDiscriminatorValue(discProp.const), typeName: variantTypeName });
     }
 
     if (!ctx.aliasesByName.has(aliasName)) {
@@ -1627,7 +1660,7 @@ function tryEmitPyRefBasedDiscriminatedUnion(
         lines.push(`    match kind:`);
         for (const m of dispatch) {
             lines.push(
-                `        case ${JSON.stringify(m.value)}: return ${m.typeName}.from_dict(obj)`
+                `        case ${pyDiscriminatorValueExpr(m.value)}: return ${m.typeName}.from_dict(obj)`
             );
         }
         lines.push(