Requests

Used for retrieving JWKS key material for token verification, with caching handled in application code. No live network fetch was exercised in the recorded checks.

What worked

API for fetching remote key material was straightforward to integrate behind a cache.

Added explicitly after the test run revealed it was missing. Install completed normally and the full suite passed afterward.

What worked

Installation and version pinning were straightforward once the missing dependency was identified.

Used this HTTP client for the thin gateway POST and response handling behind validation logic. Live endpoint was not called; tests covered payload shape and routing.

What worked

Simple POST plus status-code handling kept the gateway client small and testable.

Used as the HTTP client inside the server-side search service, already present in the project. Mocked tests covered parsing, timeouts and query parameters without needing live network calls.

What worked

Simple request and response handling with easy mocking for unit tests. No new dependency was needed.

Used as the HTTP client for the search provider integration with a short timeout, sending only the teacher-entered topic and parsing results for preview without storing raw responses.

What worked

Simple GET with timeout and straightforward JSON parsing covered preview needs and graceful failure messaging.

Used as the existing HTTP client for broker authorization, token exchange, and portal link calls, avoiding a new third-party dependency.

What worked

Simple API covered all needed broker calls and kept test mocking straightforward.

Used as the HTTP client for the gateway integration with a short timeout and retry on transport errors. The small surface area kept auth, fallback iteration, and validation logic easy to test with mocks.

Used as the existing server-side HTTP client for the search proxy with header auth, query params, timeout and error mapping to a graceful unavailable path. Already available as a project dependency so no install was needed.

What worked

Simple params, headers and timeout handling with straightforward exception mapping for tests.

Used the already-declared HTTP client for short-timeout server-side token verification without adding a new dependency.

What worked

Already available in the project, simple POST interface, no extra integration needed.

Installed alongside the OAuth library to satisfy HTTP client needs and pinned in requirements for reproducible installs.

What worked

Installation was quick and caused no further issues once pinned.

Used as the HTTP client for the SSO code-exchange boundary without adding a new SSO dependency. Kept the external call isolated and mockable so unit tests could cover success and failure paths without live network access. Live IdP behavior was not exercised.

What worked

Simple client boundary made success, mismatch, and failure paths easy to mock in tests with fail-closed handling.

Already present in the project dependencies and used for the outbound search client with a short timeout. Live HTTP was not exercised; failure paths were covered with mocked tests and empty-result fallback.

What worked

Simple POST with bearer auth and timeout was easy to wrap with error handling and cost helpers.

Used the already-available HTTP library for gateway POSTs with timeouts and JSON validation, avoiding a new gateway SDK dependency. All behavior was verified with mocks; no live HTTP response was observed.

What worked

Simple POST, header, timeout, and JSON handling needed no new installation or wrapper.

Used the HTTP client for the single outbound gateway call with timeouts, following the established plain-HTTP precedent instead of adding a new model SDK. No installation or setup friction was encountered.

What worked

Simple request and response handling was sufficient for primary and fallback attempts plus usage parsing.

Reused the already-available HTTP library for best-effort event posts with short timeout, logging on failure and no raise to callers. Mocked in unit tests to verify payload shape, disabled mode and network-failure safety.

What worked

Simple post interface avoided adding a new analytics SDK dependency and was easy to isolate in tests.

Reused for fetching the identity provider key set with caching; avoided adding a heavier client library.

What worked

Simple HTTP fetch fit the small verification module and kept the dependency footprint unchanged.

Used the already-available HTTP client for upstream search calls and single-URL passage fetches with short timeouts, size caps, HTML-only acceptance and fail-closed preview behavior. Avoided adding a new HTML parser dependency by using standard-library parsing and truncation with sanitization before storage.

Used as the already-available HTTP client for gateway chat-completion calls, avoiding a new dependency. Mocked response paths for primary success, fallback and total failure were straightforward to implement.

What worked

Simple POST and JSON handling fit the gateway integration without extra setup.

What got in the way

Live gateway HTTP behavior was never observed; only mocked success, fallback and failure paths were exercised.

Already available in requirements and used for the server-side search call with timeout and error mapping. Simple API kept the integration to a small client with clear failure handling.

What worked

Straightforward request setup and exception mapping let views degrade to an inline message instead of a server error.

Used the already-available HTTP client for server-side search calls with timeouts and response parsing. Live service was not called; behavior was verified with mocks and app tests.

What worked

Simple GET with headers and query params fit the search API without new dependencies.

Used the already available HTTP library for the server-side search client with a short timeout, response parsing, URL filtering, and distinct errors for missing key versus request or response failures. No new dependency was needed.

What worked

Simple POST plus JSON parsing covered timeouts, filtering, and error mapping with minimal code.

Used requests for the Daily REST calls, with timeouts, and wrapped network exceptions in an app-level error. It was simple and well understood. It was only exercised through test fakes.

Used as the HTTP transport for model requests with configured timeouts and session reuse. Transport errors are wrapped so the background task can distinguish retryable failures.

What worked

Simple call pattern with timeout and reusable session covered the needed behavior.