fastapi-streams 0.3.0__tar.gz → 0.4.0__tar.gz

{fastapi_streams-0.3.0 → fastapi_streams-0.4.0}/CHANGELOG.md

@@ -3,6 +3,73 @@
 All notable changes and consumer upgrade steps are recorded here. Entries marked
 unreleased describe prepared source versions that have not been published.
 
+## 0.4.0 - 2026-10-18
+
+### Breaking changes
+
+- CLI drift checks now include SDK provenance in `.fastapi-streams.json`.
+  Existing files-only manifests, a different generator version, or a changed
+  source schema now fail `check`, including source changes that leave generated
+  code identical. Regenerate once with the existing language and HTTP backend,
+  review and commit the updated manifest. This stricter drift check requires
+  a minor release under the pre-1.0 version policy.
+
+### Added
+
+- Always record generator/version, canonical schema SHA-256, target and Python
+  HTTP backend in CLI-generated manifests, sharing metadata with diagnostic
+  reports. Preserve `files` ownership, safe cleanup and read-only checks.
+  Low-level file writers can supply optional `generation` metadata.
+- Document optional operation/status-specific error decoders using the existing
+  TypeScript guard hook and cached Python TypeAdapters. Add a checked consumer
+  decoder example; unexpected JSON/text/proxy errors retain the generic fallback.
+  Generated request/event APIs, HTTP/SSE contracts and runtime dependencies stay
+  unchanged.
+
+### Upgrade from 0.3.1
+
+1. Upgrade the generator to 0.4.0 and regenerate with the same language and
+   Python HTTP backend. Commit `.fastapi-streams.json` with the generated SDK.
+2. Expect a one-time manifest diff. CI checks now detect schema or generator
+   provenance changes even when generated source code is otherwise unchanged.
+3. Existing callers, HTTP/SSE contracts and exact diagnostic allowances require
+   no migration. Optional error decoders remain consumer-controlled.
+
+## 0.3.1 - 2026-10-18
+
+### Added
+
+- Repeatable Python and Node benchmarks for generated SDK request preparation,
+  decoding/validation, SSE framing, complete consumption, fragmented chunks and
+  Python unknown-event ignoring. Reports include individual timing samples and
+  optional separate Python peak-memory measurements; no CI timing thresholds.
+- Add generation provenance and validation capabilities to version 1 diagnostic
+  reports: canonical schema SHA-256, generator version, target/HTTP backend and
+  request/event/error validation phases. Existing diagnostic fields, IDs and
+  exact reviewed allowances remain unchanged. Additional report object keys are
+  additive; the metadata does not introduce runtime checks or full JSON Schema
+  guarantees.
+
+### Performance
+
+- Reuse the JSON-value adapter for skipped unknown events and HTTP-error JSON
+  decoding. Cache top-level discriminator metadata per generated event adapter
+  instead of rebuilding its JSON Schema for every ignore-policy stream.
+- Prepare sanitized validation details only for errors that are actually raised.
+  Known events still use direct Pydantic JSON validation; malformed known events,
+  missing/non-string tags, invalid JSON and unknown nested variants still fail.
+  Public signatures, coercion, validation timing and wire encoding are unchanged.
+
+### Upgrade from 0.3.0
+
+1. Upgrade the generator to 0.3.1 and regenerate with the existing HTTP backend
+   to obtain the Python runtime improvements. Existing generated SDKs keep working.
+2. Diagnostic-report readers should tolerate the new `generation` and `validation`
+   keys. Existing exact diagnostic allowances need no migration.
+3. Continue validating server requests and domain invariants at their own
+   boundaries; consumers should reuse parsed events instead of validating the
+   same schema again. TypeScript remains static-only with no added dependency.
+
 ## 0.3.0 - 2026-10-18
 
 ### Breaking changes

{fastapi_streams-0.3.0 → fastapi_streams-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-streams
-Version: 0.3.0
+Version: 0.4.0
 Summary: Typed FastAPI streams with generated TypeScript and Python clients.
 Project-URL: Documentation, https://github.com/mathisarends/canon/tree/main/packages/fastapi-streams/docs
 Project-URL: Source, https://github.com/mathisarends/canon/tree/main/packages/fastapi-streams

{fastapi_streams-0.3.0 → fastapi_streams-0.4.0}/docs/clients.md

@@ -121,6 +121,15 @@ remain ordinary members of the user-defined union.
 
 ## HTTP error contracts
 
+Keep schema validation at transport boundaries. Python prepares and validates
+requests at the method call and validates received events during iteration.
+Pass those parsed event models onward instead of serializing them to dictionaries
+and validating the same schema again. Server request validation remains necessary
+regardless of SDK checks; authentication, authorization and domain invariants have
+separate responsibilities. Canon composition does not need an additional event
+validator around Streams. TypeScript keeps its documented static-only behavior;
+applications needing runtime event checks can validate once before using a value.
+
 Python request parameters and JSON bodies are validated when calling the method;
 catch Pydantic `ValidationError` around that call. Network and event errors occur
 while iterating. See the [validation matrix and CI policy](codegen.md#validation-support-matrix).
@@ -186,6 +195,65 @@ the original status, response, and diagnostics. Schema unions with permissive
 variants may accept a broad range of bodies; inspect the parsed variant before
 using its fields. Existing limits on bounded HTTP diagnostics still apply.
 
+### Optional consumer decoders
+
+Build a decoder once per operation/status around the existing guard hook when
+several callers need the same declared error body. For example, this adapter
+accepts a consumer-provided validator with no additional SDK dependency:
+
+```typescript
+import { isHttpError, type StreamRunEventsErrorBody } from "./generated/index.js";
+
+function decodeValidationError(
+  error: unknown,
+  isBody: (value: unknown) => value is StreamRunEventsErrorBody,
+): StreamRunEventsErrorBody | undefined {
+  if (isHttpError(error, isBody) && error.status === 422) return error.details;
+  return undefined;
+}
+```
+
+Supply a handwritten guard or an existing validator that checks every field of
+the generated alias. A type assertion alone does not validate a response. Guards
+must validate the original value: if a decoder coerces or transforms data, use
+its successfully parsed output instead of narrowing the original `error.details`.
+Use this helper only for the operation whose errors the alias describes.
+
+If decoding returns `undefined`, continue handling the original `HttpError`
+generically or rethrow it. Its status, response and JSON/text details remain
+available, including unexpected proxy responses. Validators run only for SDK
+HTTP errors; `isHttpError` leaves network/stream failures alone. Status checks
+remain explicit because a matching body does not establish an HTTP status.
+The [TypeScript example](../examples/agent_runs/errors.ts) includes a complete
+guard and reusable decoder with this fallback behavior.
+
+In Python, construct and reuse an adapter rather than rebuilding it for each
+exception:
+
+```python
+from pydantic import TypeAdapter, ValidationError
+from myapp.generated import HttpError
+from myapp.generated.models import StreamRunEventsErrorBody
+
+error_body = TypeAdapter(StreamRunEventsErrorBody)
+
+
+def decode_validation_error(error: HttpError) -> StreamRunEventsErrorBody | None:
+    if error.status != 422:
+        return None
+    try:
+        return error_body.validate_python(error.details)
+    except ValidationError:
+        return None
+```
+
+Use the returned parsed body on success and retain the original exception for
+fallback handling. This alias describes an object response, so `None` can
+represent failure here; for a nullable body alias, use a separate success flag
+or sentinel. Neither recipe changes SDK defaults or automatically validates all
+HTTP failures. Diagnostic reports correctly retain `consumer_controlled` for
+HTTP-error body validation.
+
 The checked consumer examples show HTTP validation errors, fallback handling,
 stream parsing/transport errors, and ordinary application error events:
 

{fastapi_streams-0.3.0 → fastapi_streams-0.4.0}/docs/codegen.md

@@ -117,6 +117,35 @@ generated files without deleting neighboring handwritten files. Use a dedicated
 output directory for each language. Unsafe paths and generated-name collisions
 fail explicitly.
 
+### SDK provenance
+
+CLI generation always writes `.fastapi-streams.json` alongside the SDK. Commit
+this file with the generated sources. Its existing `files` list still controls
+ownership and cleanup; the additional `generation` object contains the same
+provenance as an optional diagnostic report:
+
+| Field | Meaning |
+| --- | --- |
+| `generator`, `generator_version` | Generator distribution and version |
+| `schema_sha256` | SHA-256 of the complete source OpenAPI document |
+| `schema_hash_encoding` | `canonical-json-v1`: JSON with recursively sorted keys, compact separators and UTF-8 without ASCII escaping |
+| `target` | `python` or `typescript` |
+| `python_http_client` | `httpx` / `httpx2` for Python, JSON null for TypeScript |
+
+There are no timestamps or local paths. Formatting and object-key order do not
+affect the schema hash; changes to any schema content do, including descriptions
+and components unused by the SDK. This identifies the input and configuration;
+it is not a signature or an integrity check of the generated sources.
+
+`check` compares the manifest as well as SDK sources. A different generator
+version or source hash is drift even when the emitted code is identical.
+Regenerate once with the chosen language and existing HTTP backend to upgrade a
+legacy files-only manifest, then commit the manifest diff. Checks remain
+read-only; generation retains neighboring handwritten files and only removes
+previously owned stale files. No diagnostic report is required for provenance.
+The low-level `write_files` API accepts optional `generation` metadata; without
+it, its files-only behavior remains available for callers writing raw file maps.
+
 ## Runtime validation and unknown variants
 
 Python validates path, query and header parameters and JSON request bodies at the
@@ -191,6 +220,26 @@ including inline schemas and referenced component definitions. Shared definition
 identify each affected operation; unused components do not generate warnings.
 SSE framing metadata is outside generated event-model validation.
 
+The version 1 report also carries additive `generation` and `validation` objects.
+Consumers should tolerate additional object keys. `generation` records the
+generator name/version, target, selected Python HTTP library (null for TypeScript)
+and `schema_sha256`. The hash covers the complete parsed OpenAPI document,
+including unused definitions. Its `canonical-json-v1` encoding is Python
+`json.dumps(document, sort_keys=True, separators=(",", ":"), ensure_ascii=False)`
+encoded as UTF-8. Whitespace and object-key order in the input file do not affect
+the hash; array order and values do. It is a content identifier, not a signature
+or proof of schema enforcement.
+
+`validation` distinguishes parameter/body validation at `method_call`, event
+decoding at `iteration` and HTTP-error handling at `consumer_controlled`.
+TypeScript parameter/body schema checks are `not_performed`. Each boundary has
+a `schema_validation` boolean, with `json_decoding: true` for events. Python's
+`runtime_scope` is `generated_types_and_supported_constraints`; TypeScript's is
+`json_decoding_only`. Both set `full_json_schema: false`. These target capabilities
+describe supported boundaries, even if an operation has no parameters or body;
+source-specific limitations remain in `diagnostics` with their accepted status.
+The report is generated only when requested and adds no SDK runtime checks.
+
 `unsupported-constraint` identifies an unenforced rule for the selected target;
 TypeScript also diagnoses Python-supported scalar constraints because TypeScript
 has no runtime schema validator. Python's `optional-discriminator` diagnoses event

{fastapi_streams-0.3.0 → fastapi_streams-0.4.0}/docs/development.md

@@ -88,6 +88,35 @@ outside the checkout they invoke the installed `fastapi-streams` command, exerci
 and consume an event through the generated Python SDK. Metadata and `__version__`
 must match the release version in `pyproject.toml`.
 
+## Generated SDK performance
+
+From the workspace root, use the locked environment and installed Node tooling:
+
+```console
+uv run --locked python packages/fastapi-streams/scripts/benchmark_runtime.py --memory --output dist/streams-baseline.json
+```
+
+The harness generates both SDKs from the same small discriminated-union contract.
+It measures request preparation separately from decoding, framing and complete
+HTTP/SSE consumption with an in-memory HTTPX transport or Fetch response. Cases
+cover small token events, nested batches, seven-byte fragments and Python's
+unknown-event ignore policy. Python validates generated models; TypeScript only
+decodes JSON. Their decoding results do not represent equivalent guarantees.
+
+Reports record source location, generator/runtime versions, platform, payload
+sizes, individual samples, median CPU/wall time per request or input event, and
+throughput. Ignore-policy throughput counts skipped input events too. `--memory`
+adds a separate Python traced peak-memory sample; it does not instrument timings
+or count total allocations. There are three warmup iterations per case. These
+are warmed batch measurements, not individual-event latency percentiles, cold
+startup measurements, real-network results or Hermes deployment evidence.
+
+Use `--runtime python` or `--runtime typescript` for focused runs. Adjust
+`--events`, `--iterations` and `--rounds` for longer samples. For a comparison,
+run the same harness with `--source-dir` pointing to the other revision's Streams
+package directory, keeping the interpreter, dependencies and arguments fixed.
+Repeat runs to assess noise; ordinary CI does not enforce timing thresholds.
+
 ## Supported scope and roadmap
 
 GET/POST JSON SSE data; scalar path and header parameters; scalar/array query parameters;

{fastapi_streams-0.3.0 → fastapi_streams-0.4.0}/examples/agent_runs/errors.py

@@ -8,6 +8,8 @@ from examples.agent_runs.generated_python import (
 )
 from examples.agent_runs.generated_python.models import StreamRunEventsErrorBody
 
+_ERROR_BODY = TypeAdapter(StreamRunEventsErrorBody)
+
 
 async def consume_with_errors(client: Client, run_id: str) -> None:
     try:
@@ -19,9 +21,7 @@ async def consume_with_errors(client: Client, run_id: str) -> None:
     except HttpError as error:
         if error.status == 422:
             try:
-                body = TypeAdapter(StreamRunEventsErrorBody).validate_python(
-                    error.details
-                )
+                body = _ERROR_BODY.validate_python(error.details)
             except ValidationError:
                 pass
             else:

{fastapi_streams-0.3.0 → fastapi_streams-0.4.0}/examples/agent_runs/errors.ts

@@ -15,8 +15,9 @@ export async function consumeWithErrors(
     }
   } catch (error: unknown) {
     if (options.signal?.aborted) throw error;
-    if (isHttpError(error, isValidationErrorBody) && error.status === 422) {
-      console.error("Invalid stream parameters", error.details.detail ?? []);
+    const body = decodeValidationError(error);
+    if (body !== undefined) {
+      console.error("Invalid stream parameters", body.detail ?? []);
       return;
     }
     if (error instanceof HttpError) {
@@ -30,6 +31,12 @@ export async function consumeWithErrors(
   }
 }
 
+// Consumer-local decoder: scope the generated body alias to this operation/status.
+export function decodeValidationError(error: unknown): StreamRunEventsErrorBody | undefined {
+  if (isHttpError(error, isValidationErrorBody) && error.status === 422) return error.details;
+  return undefined;
+}
+
 function isValidationErrorBody(value: unknown): value is StreamRunEventsErrorBody {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
   if (!("detail" in value)) return true;

fastapi_streams-0.4.0/examples/agent_runs/generated/.fastapi-streams.json

@@ -0,0 +1,19 @@
+{
+  "files": [
+    "agent-runs/api.ts",
+    "agent-runs/index.ts",
+    "client.ts",
+    "index.ts",
+    "transport/errors.ts",
+    "transport/sse.ts",
+    "types.ts"
+  ],
+  "generation": {
+    "generator": "fastapi-streams",
+    "generator_version": "0.4.0",
+    "python_http_client": null,
+    "schema_hash_encoding": "canonical-json-v1",
+    "schema_sha256": "f23def53557e9d381bada00de07054f0a105eceaefdf5f47eb3168a0e8a05c7f",
+    "target": "typescript"
+  }
+}

fastapi_streams-0.4.0/examples/agent_runs/generated_python/.fastapi-streams.json

@@ -0,0 +1,19 @@
+{
+  "files": [
+    "__init__.py",
+    "agent_runs/__init__.py",
+    "agent_runs/api.py",
+    "client.py",
+    "models.py",
+    "py.typed",
+    "runtime.py"
+  ],
+  "generation": {
+    "generator": "fastapi-streams",
+    "generator_version": "0.4.0",
+    "python_http_client": "httpx",
+    "schema_hash_encoding": "canonical-json-v1",
+    "schema_sha256": "f23def53557e9d381bada00de07054f0a105eceaefdf5f47eb3168a0e8a05c7f",
+    "target": "python"
+  }
+}

{fastapi_streams-0.3.0/fastapi_streams/codegen/templates/python → fastapi_streams-0.4.0/examples/agent_runs/generated_python}/runtime.py

@@ -5,12 +5,15 @@ import codecs
 from collections.abc import AsyncGenerator, Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum
+from functools import cache
 from typing import Literal, cast
 
 import httpx
 from pydantic import JsonValue, TypeAdapter, ValidationError
 from pydantic_core import ErrorDetails
 
+_JSON_ADAPTER = TypeAdapter[JsonValue](JsonValue)
+
 
 class TransportError(Exception):
     pass
@@ -180,19 +183,11 @@ class Transport:
         options: RequestOptions | None = None,
     ) -> AsyncGenerator[T, None]:
         discriminator: str | None = None
-        known_tags: set[str] = set()
+        known_tags: frozenset[str] = frozenset()
         if options and options.unknown_events not in {"error", "ignore"}:
             raise ValueError("unknown_events must be 'error' or 'ignore'")
         if options and options.unknown_events == "ignore":
-            schema = adapter.json_schema()
-            policy = schema.get("discriminator", {})
-            discriminator = policy.get("propertyName")
-            known_tags = set(policy.get("mapping", {}))
-            if not isinstance(discriminator, str) or not known_tags:
-                raise ValueError(
-                    "unknown_events='ignore' requires a top-level "
-                    "discriminated event union"
-                )
+            discriminator, known_tags = _unknown_event_policy(adapter)
         request_headers = self.headers.copy()
         request_headers.update(headers)
         if options and options.headers:
@@ -223,11 +218,7 @@ class Transport:
                         failure = exc
                     text = raw.decode("utf-8", errors="replace")
                     try:
-                        details = (
-                            TypeAdapter[JsonValue](JsonValue).validate_json(text)
-                            if text
-                            else None
-                        )
+                        details = _JSON_ADAPTER.validate_json(text) if text else None
                     except ValidationError:
                         details = text
                     raise HttpError(response, details) from failure
@@ -245,6 +236,16 @@ class Transport:
                     try:
                         yield adapter.validate_json(payload)
                     except ValidationError as exc:
+                        if discriminator is not None:
+                            try:
+                                value = _JSON_ADAPTER.validate_json(payload)
+                            except ValidationError:
+                                pass
+                            else:
+                                if isinstance(value, dict):
+                                    tag = value.get(discriminator)
+                                    if isinstance(tag, str) and tag not in known_tags:
+                                        continue
                         # Exclude input and arbitrary validator context from public
                         # diagnostics. The original cause remains available explicitly.
                         details = exc.errors(
@@ -257,22 +258,6 @@ class Transport:
                             if any(error["type"] == "json_invalid" for error in details)
                             else "invalid_event_schema"
                         )
-                        if discriminator is not None:
-                            try:
-                                value = TypeAdapter[JsonValue](JsonValue).validate_json(
-                                    payload
-                                )
-                            except ValidationError:
-                                raise StreamParseError(
-                                    payload,
-                                    operation_id=operation_id,
-                                    category="invalid_json",
-                                    validation_errors=details,
-                                ) from exc
-                            if isinstance(value, dict):
-                                tag = value.get(discriminator)
-                                if isinstance(tag, str) and tag not in known_tags:
-                                    continue
                         raise StreamParseError(
                             payload,
                             operation_id=operation_id,
@@ -285,6 +270,19 @@ class Transport:
             raise TransportError("Invalid UTF-8 in SSE stream") from exc
 
 
+@cache
+def _unknown_event_policy[T](adapter: TypeAdapter[T]) -> tuple[str, frozenset[str]]:
+    schema = adapter.json_schema()
+    policy = schema.get("discriminator", {})
+    discriminator = policy.get("propertyName")
+    known_tags = frozenset(policy.get("mapping", {}))
+    if not isinstance(discriminator, str) or not known_tags:
+        raise ValueError(
+            "unknown_events='ignore' requires a top-level discriminated event union"
+        )
+    return discriminator, known_tags
+
+
 def _preserve_numbers[T](original: object, validated: T) -> T:
     if (
         type(original) is int

{fastapi_streams-0.3.0 → fastapi_streams-0.4.0}/fastapi_streams/__init__.py

@@ -1,4 +1,4 @@
 from fastapi_streams.router import StreamRouter
 
 __all__ = ["StreamRouter"]
-__version__ = "0.3.0"
+__version__ = "0.4.0"

{fastapi_streams-0.3.0 → fastapi_streams-0.4.0}/fastapi_streams/codegen/cli.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import hashlib
 import importlib
 import json
 import sys
@@ -9,6 +10,7 @@ from typing import TYPE_CHECKING, cast
 
 from fastapi import FastAPI
 
+from fastapi_streams import __version__
 from fastapi_streams.codegen.openapi import ContractError, Document, export_schema
 from fastapi_streams.codegen.writer import write_files
 
@@ -103,6 +105,10 @@ def main(argv: list[str] | None = None) -> int:
             document = json.loads(args.schema.read_text(encoding="utf-8"))
             if not isinstance(document, dict):
                 raise ContractError("The OpenAPI document must be an object")
+            document = cast(Document, document)
+            generation = _generation_metadata(
+                document, args.language, args.python_http_client or "httpx"
+            )
             if args.command == "check" and args.app:
                 expected = export_schema(_load_app(args.app))
                 if expected != document:
@@ -112,12 +118,15 @@ def main(argv: list[str] | None = None) -> int:
                     )
                     return 1
             diagnostics: list[GenerationDiagnostic] = []
-            contract = build_ir(
-                cast(Document, document), target=args.language, diagnostics=diagnostics
-            )
+            contract = build_ir(document, target=args.language, diagnostics=diagnostics)
             # Reports precede strict-policy failures, so CI can review new IDs.
             if args.diagnostics:
-                _write_diagnostics(args.diagnostics, diagnostics, set())
+                _write_diagnostics(
+                    args.diagnostics,
+                    diagnostics,
+                    set(),
+                    generation,
+                )
             accepted: set[str] = (
                 accepted_diagnostics(
                     diagnostics, json.loads(args.allow_diagnostics.read_text("utf-8"))
@@ -126,7 +135,12 @@ def main(argv: list[str] | None = None) -> int:
                 else set()
             )
             if args.diagnostics:
-                _write_diagnostics(args.diagnostics, diagnostics, accepted)
+                _write_diagnostics(
+                    args.diagnostics,
+                    diagnostics,
+                    accepted,
+                    generation,
+                )
             pending = [item for item in diagnostics if item.id not in accepted]
             emit_diagnostics(pending)
             if args.strict and pending:
@@ -141,7 +155,9 @@ def main(argv: list[str] | None = None) -> int:
                 if args.language == "python"
                 else generate_typescript(contract)
             )
-            changed = write_files(args.output, generated, check=args.check)
+            changed = write_files(
+                args.output, generated, check=args.check, generation=generation
+            )
             if args.check and changed:
                 for path in changed:
                     print(f"Out of date: {path}", file=sys.stderr)
@@ -167,14 +183,62 @@ def _load_app(value: str) -> FastAPI:
     return app
 
 
+def _generation_metadata(
+    document: Document, target: str, http_client: str
+) -> dict[str, str | None]:
+    # Share canonical provenance between manifests and optional reports.
+    encoded = json.dumps(
+        document, sort_keys=True, separators=(",", ":"), ensure_ascii=False
+    ).encode("utf-8")
+    return {
+        "generator": "fastapi-streams",
+        "generator_version": __version__,
+        "schema_sha256": hashlib.sha256(encoded).hexdigest(),
+        "schema_hash_encoding": "canonical-json-v1",
+        "target": target,
+        "python_http_client": http_client if target == "python" else None,
+    }
+
+
 def _write_diagnostics(
-    path: Path, diagnostics: list[GenerationDiagnostic], accepted: set[str]
+    path: Path,
+    diagnostics: list[GenerationDiagnostic],
+    accepted: set[str],
+    generation: dict[str, str | None],
 ) -> None:
+    python = generation["target"] == "python"
+    request_phase = "method_call" if python else "not_performed"
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(
         json.dumps(
             {
                 "version": 1,
+                "generation": generation,
+                "validation": {
+                    "full_json_schema": False,
+                    "runtime_scope": (
+                        "generated_types_and_supported_constraints"
+                        if python
+                        else "json_decoding_only"
+                    ),
+                    "parameters": {
+                        "phase": request_phase,
+                        "schema_validation": python,
+                    },
+                    "request_body": {
+                        "phase": request_phase,
+                        "schema_validation": python,
+                    },
+                    "events": {
+                        "phase": "iteration",
+                        "schema_validation": python,
+                        "json_decoding": True,
+                    },
+                    "http_error_bodies": {
+                        "phase": "consumer_controlled",
+                        "schema_validation": False,
+                    },
+                },
                 "diagnostics": [
                     item.to_dict(accepted=item.id in accepted) for item in diagnostics
                 ],