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

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

@@ -3,6 +3,38 @@
 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-streams
-Version: 0.3.1
+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.1 → fastapi_streams-0.4.0}/docs/clients.md

@@ -195,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.1 → 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

{fastapi_streams-0.3.1 → 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.1 → 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.1 → fastapi_streams-0.4.0}/fastapi_streams/__init__.py

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

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

@@ -106,6 +106,9 @@ def main(argv: list[str] | None = None) -> int:
             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:
@@ -122,9 +125,7 @@ def main(argv: list[str] | None = None) -> int:
                     args.diagnostics,
                     diagnostics,
                     set(),
-                    document,
-                    args.language,
-                    args.python_http_client or "httpx",
+                    generation,
                 )
             accepted: set[str] = (
                 accepted_diagnostics(
@@ -138,9 +139,7 @@ def main(argv: list[str] | None = None) -> int:
                     args.diagnostics,
                     diagnostics,
                     accepted,
-                    document,
-                    args.language,
-                    args.python_http_client or "httpx",
+                    generation,
                 )
             pending = [item for item in diagnostics if item.id not in accepted]
             emit_diagnostics(pending)
@@ -156,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)
@@ -182,33 +183,37 @@ 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],
-    document: Document,
-    target: str,
-    http_client: str,
+    generation: dict[str, str | None],
 ) -> None:
-    # Canonical JSON binds reports to schema content, independent of file layout.
-    encoded = json.dumps(
-        document, sort_keys=True, separators=(",", ":"), ensure_ascii=False
-    ).encode("utf-8")
-    python = target == "python"
+    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": {
-                    "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 python else None,
-                },
+                "generation": generation,
                 "validation": {
                     "full_json_schema": False,
                     "runtime_scope": (

{fastapi_streams-0.3.1 → fastapi_streams-0.4.0}/fastapi_streams/codegen/writer.py

@@ -8,7 +8,11 @@ MANIFEST = ".fastapi-streams.json"
 
 
 def write_files(
-    output: Path, files: Mapping[str, str], *, check: bool = False
+    output: Path,
+    files: Mapping[str, str],
+    *,
+    check: bool = False,
+    generation: Mapping[str, str | None] | None = None,
 ) -> tuple[Path, ...]:
     """Write deterministic output; only remove stale files owned by the manifest.
 
@@ -17,7 +21,10 @@ def write_files(
     expected = dict(files)
     if MANIFEST in expected:
         raise ValueError(f"{MANIFEST} is reserved")
-    expected[MANIFEST] = json.dumps({"files": sorted(files)}, indent=2) + "\n"
+    metadata: dict[str, Any] = {"files": sorted(files)}
+    if generation is not None:
+        metadata["generation"] = dict(generation)
+    expected[MANIFEST] = json.dumps(metadata, indent=2, sort_keys=True) + "\n"
     manifest = _owned_path(output, MANIFEST)
     previous: set[str] = set()
     if manifest.exists():

{fastapi_streams-0.3.1 → fastapi_streams-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-streams"
-version = "0.3.1"
+version = "0.4.0"
 description = "Typed FastAPI streams with generated TypeScript and Python clients."
 readme = "README.md"
 requires-python = ">=3.12"

{fastapi_streams-0.3.1 → fastapi_streams-0.4.0}/scripts/smoke_package.py

@@ -133,6 +133,11 @@ def main() -> None:
                 args.http_client if language == "python" else None
             )
             assert len(report["generation"]["schema_sha256"]) == 64
+            manifest = json.loads(
+                (working / output / ".fastapi-streams.json").read_text()
+            )
+            assert manifest["generation"] == report["generation"]
+            assert client_file in manifest["files"]
             assert report["validation"]["full_json_schema"] is False
             assert report["validation"]["events"] == {
                 "phase": "iteration",

{fastapi_streams-0.3.1 → fastapi_streams-0.4.0}/tests/codegen/test_codegen.py

@@ -11,6 +11,44 @@ from fastapi_streams.codegen.typescript import generate_typescript
 from fastapi_streams.codegen.writer import MANIFEST, write_files
 
 
+@pytest.mark.parametrize(
+    "target,backend", [("python", "httpx"), ("python", "httpx2"), ("typescript", None)]
+)
+def test_cli_upgrades_legacy_manifest_without_a_diagnostic_report(
+    tmp_path, target, backend
+):
+    schema, output = tmp_path / "schema.json", tmp_path / "sdk"
+    document = export_schema(app)
+    schema.write_text(json.dumps(document), encoding="utf-8")
+    write_files(output, {"stale.txt": "old"})
+    handwritten = output / "handwritten.txt"
+    handwritten.write_text("keep", encoding="utf-8")
+    flags = ["--schema", str(schema), "--language", target, "--output", str(output)]
+    if backend:
+        flags += ["--python-http-client", backend]
+    legacy = (output / MANIFEST).read_bytes()
+    assert main(["check", *flags]) == 1
+    assert (output / MANIFEST).read_bytes() == legacy
+    assert main(["generate", *flags]) == 0
+    manifest = json.loads((output / MANIFEST).read_bytes())
+    assert manifest["generation"]["target"] == target
+    assert manifest["generation"]["python_http_client"] == backend
+    assert manifest["files"] == sorted(
+        path.relative_to(output).as_posix()
+        for path in output.rglob("*")
+        if path.is_file() and path.name not in {MANIFEST, "handwritten.txt"}
+    )
+    assert not (output / "stale.txt").exists()
+    assert handwritten.read_text() == "keep"
+    assert main(["check", *flags]) == 0
+    # A different generator version is drift even if source files are identical.
+    manifest["generation"]["generator_version"] = "0.0.1"
+    (output / MANIFEST).write_text(json.dumps(manifest), encoding="utf-8")
+    stale = (output / MANIFEST).read_bytes()
+    assert main(["check", *flags]) == 1
+    assert (output / MANIFEST).read_bytes() == stale
+
+
 def test_ir_and_types_are_typed_and_streams_only():
     contract = build_ir(export_schema(app))
     assert {op.operation_id for op in contract.operations} == {

{fastapi_streams-0.3.1 → fastapi_streams-0.4.0}/tests/codegen/test_nested_models.py

@@ -5,15 +5,13 @@ import httpx
 import pytest
 from pydantic import TypeAdapter, ValidationError
 
+from fastapi_streams.codegen.cli import main
 from fastapi_streams.codegen.ir import build_ir
 from fastapi_streams.codegen.openapi import (
     ContractError,
     export_schema,
     validate_contract,
 )
-from fastapi_streams.codegen.python import generate_python
-from fastapi_streams.codegen.typescript import generate_typescript
-from fastapi_streams.codegen.writer import write_files
 from tests.fixtures.generated_python import Client
 from tests.fixtures.generated_python.models import (
     FixtureEvent,
@@ -76,13 +74,25 @@ def test_fixture_generation_is_current():
     document = export_schema(app)
     snapshot = Path("tests/fixtures/models.openapi.json")
     assert json.loads(snapshot.read_text()) == document
-    contract = build_ir(document)
-    assert not write_files(
-        Path("tests/fixtures/generated"), generate_typescript(contract), check=True
-    )
-    assert not write_files(
-        Path("tests/fixtures/generated_python"), generate_python(contract), check=True
-    )
+    for language, directory in (
+        ("typescript", "generated"),
+        ("python", "generated_python"),
+    ):
+        assert (
+            main(
+                [
+                    "check",
+                    "--schema",
+                    str(snapshot),
+                    "--language",
+                    language,
+                    "--output",
+                    f"tests/fixtures/{directory}",
+                    "--strict",
+                ]
+            )
+            == 0
+        )
 
 
 def test_refs_in_properties_named_like_schema_annotations_are_checked():

{fastapi_streams-0.3.1 → fastapi_streams-0.4.0}/tests/codegen/test_python_client.py

@@ -2,7 +2,6 @@ import asyncio
 import importlib.util
 import sys
 from enum import StrEnum
-from pathlib import Path
 
 import httpx
 import pytest
@@ -22,7 +21,6 @@ from fastapi_streams.codegen.cli import main
 from fastapi_streams.codegen.ir import build_ir
 from fastapi_streams.codegen.openapi import export_schema
 from fastapi_streams.codegen.python import generate_python
-from fastapi_streams.codegen.writer import write_files
 
 
 class Chunks(httpx.AsyncByteStream):
@@ -379,8 +377,20 @@ def test_python_codegen_cli_and_snapshot(tmp_path):
     contract = build_ir(export_schema(app))
     files = generate_python(contract)
     assert files == generate_python(contract)
-    assert not write_files(
-        Path("examples/agent_runs/generated_python"), files, check=True
+    assert (
+        main(
+            [
+                "check",
+                "--schema",
+                "tests/fixtures/agent_runs.openapi.json",
+                "--language",
+                "python",
+                "--output",
+                "examples/agent_runs/generated_python",
+                "--strict",
+            ]
+        )
+        == 0
     )
     schema = tmp_path / "schema.json"
     assert (

{fastapi_streams-0.3.1 → fastapi_streams-0.4.0}/tests/codegen/test_structured_diagnostics.py

@@ -237,6 +237,9 @@ def test_report_describes_actual_target_phases_and_stable_schema_content(
     original = report.read_bytes()
     result = json.loads(original)
     generation = result["generation"]
+    manifest_path = tmp_path / "sdk" / ".fastapi-streams.json"
+    manifest_bytes = manifest_path.read_bytes()
+    assert json.loads(manifest_bytes)["generation"] == generation
     assert generation["generator"] == "fastapi-streams"
     assert generation["generator_version"] == __version__
     assert generation["target"] == target
@@ -266,11 +269,18 @@ def test_report_describes_actual_target_phases_and_stable_schema_content(
     )
     assert main(["check", *flags]) == 0
     assert report.read_bytes() == original
+    assert manifest_path.read_bytes() == manifest_bytes
     # The complete document participates, including components not emitted by SDKs.
     document["info"]["description"] = "Changed contract provenance"
     schema.write_text(json.dumps(document), encoding="utf-8")
-    assert main(["check", *flags]) == 0
+    assert main(["check", *flags]) == 1
+    assert manifest_path.read_bytes() == manifest_bytes
     assert (
         json.loads(report.read_bytes())["generation"]["schema_sha256"]
         != generation["schema_sha256"]
     )
+    assert main(["generate", *flags]) == 0
+    assert (
+        json.loads(manifest_path.read_bytes())["generation"]
+        == json.loads(report.read_bytes())["generation"]
+    )

fastapi_streams-0.4.0/tests/fixtures/generated/.fastapi-streams.json

@@ -0,0 +1,19 @@
+{
+  "files": [
+    "client.ts",
+    "fixtures/api.ts",
+    "fixtures/index.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": "b12c8dd481b9c592222dc45a26586aecc8899702e42ccc0deed834d91a7cfe41",
+    "target": "typescript"
+  }
+}

fastapi_streams-0.4.0/tests/fixtures/generated_python/.fastapi-streams.json

@@ -0,0 +1,19 @@
+{
+  "files": [
+    "__init__.py",
+    "client.py",
+    "fixtures/__init__.py",
+    "fixtures/api.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": "b12c8dd481b9c592222dc45a26586aecc8899702e42ccc0deed834d91a7cfe41",
+    "target": "python"
+  }
+}

{fastapi_streams-0.3.1 → fastapi_streams-0.4.0}/tests/typescript/errors.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
 import { createClient, HttpError, isHttpError, TransportError } from "../../examples/agent_runs/generated/index.js";
-import { consumeWithErrors } from "../../examples/agent_runs/errors.js";
+import { consumeWithErrors, decodeValidationError } from "../../examples/agent_runs/errors.js";
 
 type MissingProblem = {
   code: "missing";
@@ -67,3 +67,18 @@ test("consumer example handles validated HTTP errors and rethrows unexpected bod
     await assert.rejects(() => consumeWithErrors(makeClient(unexpected), "demo"), HttpError);
   }
 });
+
+test("consumer decoder retains generic failures and checks the actual status", () => {
+  const body = { detail: [{ loc: ["run_id", 0], msg: "Invalid", type: "value_error" }] };
+  const response = new Response(null, { status: 422 });
+  const expected = new HttpError(422, body, response);
+  assert.equal(decodeValidationError(expected), body);
+  for (const details of ["Bad gateway", undefined, null, [], { detail: [{}] }]) {
+    const error = new HttpError(422, details, response);
+    assert.equal(decodeValidationError(error), undefined);
+    assert.equal(error.details, details);
+    assert.equal(error.response, response);
+  }
+  assert.equal(decodeValidationError(new HttpError(502, body, response)), undefined);
+  assert.equal(decodeValidationError(new TransportError("offline")), undefined);
+});

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

@@ -1,11 +0,0 @@
-{
-  "files": [
-    "agent-runs/api.ts",
-    "agent-runs/index.ts",
-    "client.ts",
-    "index.ts",
-    "transport/errors.ts",
-    "transport/sse.ts",
-    "types.ts"
-  ]
-}

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

@@ -1,11 +0,0 @@
-{
-  "files": [
-    "__init__.py",
-    "agent_runs/__init__.py",
-    "agent_runs/api.py",
-    "client.py",
-    "models.py",
-    "py.typed",
-    "runtime.py"
-  ]
-}

fastapi_streams-0.3.1/tests/fixtures/generated/.fastapi-streams.json

@@ -1,11 +0,0 @@
-{
-  "files": [
-    "client.ts",
-    "fixtures/api.ts",
-    "fixtures/index.ts",
-    "index.ts",
-    "transport/errors.ts",
-    "transport/sse.ts",
-    "types.ts"
-  ]
-}

fastapi_streams-0.3.1/tests/fixtures/generated_python/.fastapi-streams.json

@@ -1,11 +0,0 @@
-{
-  "files": [
-    "__init__.py",
-    "client.py",
-    "fixtures/__init__.py",
-    "fixtures/api.py",
-    "models.py",
-    "py.typed",
-    "runtime.py"
-  ]
-}