Migrate integration and provider HTTP types (PR 13)

crates/trusted-server-adapter-fastly/src/main.rs

@@ -590,7 +590,6 @@ async fn route_request(
             false,
         ),
         (m, path) if integration_registry.has_route(&m, path) => {
-            let fastly_req = compat::to_fastly_request(req);
             let result = integration_registry
                 .handle_proxy(ProxyDispatchInput {
                     method: &m,
@@ -599,15 +598,14 @@ async fn route_request(
                     kv: kv_graph.as_ref(),
                     ec_context: &mut ec_context,
                     services: runtime_services,
-                    req: fastly_req,
+                    req,
                 })
                 .await
                 .unwrap_or_else(|| {
                     Err(Report::new(TrustedServerError::BadRequest {
                         message: format!("Unknown integration route: {path}"),
                     }))
-                })
-                .map(compat::from_fastly_response);
+                });
             (result, true)
         }
 

crates/trusted-server-adapter-fastly/src/platform.rs

@@ -491,7 +491,7 @@ impl PlatformHttpClient for FastlyPlatformHttpClient {
             .map(PlatformPendingRequest::new)
             .collect();
 
-        let ready = match result {
+        let (ready, failed_backend_name) = match result {
             Ok(fastly_resp) => {
                 let backend_name = fastly_resp
                     .get_backend_name()
@@ -500,15 +500,27 @@ impl PlatformHttpClient for FastlyPlatformHttpClient {
                         ""
                     })
                     .to_string();
-                fastly_response_to_platform(fastly_resp, backend_name, false)
+                (
+                    fastly_response_to_platform(fastly_resp, backend_name, false),
+                    None,
+                )
             }
             Err(e) => {
-                Err(Report::new(PlatformError::HttpClient)
-                    .attach(format!("fastly select error: {e}")))
+                let failed_name = e.backend_name().to_string();
+                (
+                    Err(Report::new(PlatformError::HttpClient).attach(format!(
+                        "fastly select error for backend '{failed_name}': {e}"
+                    ))),
+                    Some(failed_name),
+                )
             }
         };
 
-        Ok(PlatformSelectResult { ready, remaining })
+        Ok(PlatformSelectResult {
+            ready,
+            remaining,
+            failed_backend_name,
+        })
     }
 }
 

crates/trusted-server-adapter-fastly/src/route_tests.rs

@@ -7,7 +7,6 @@ use edgezero_core::body::Body as EdgeBody;
 use edgezero_core::http::response_builder as edge_response_builder;
 use edgezero_core::key_value_store::NoopKvStore;
 use error_stack::Report;
-use fastly::http::request::PendingRequest;
 use fastly::http::{header, Method, StatusCode};
 use fastly::Request;
 use serde_json::json;
@@ -313,24 +312,25 @@ impl PlatformGeo for NoopGeo {
 
 struct DisabledRouteProvider;
 
+#[async_trait::async_trait(?Send)]
 impl AuctionProvider for DisabledRouteProvider {
     fn provider_name(&self) -> &'static str {
         "disabled-route"
     }
 
-    fn request_bids(
+    async fn request_bids(
         &self,
         _request: &AuctionRequest,
         _context: &AuctionContext<'_>,
-    ) -> Result<PendingRequest, Report<TrustedServerError>> {
+    ) -> Result<PlatformPendingRequest, Report<TrustedServerError>> {
         Err(Report::new(TrustedServerError::Auction {
             message: "disabled route provider should not launch requests".to_string(),
         }))
     }
 
-    fn parse_response(
+    async fn parse_response(
         &self,
-        _response: fastly::Response,
+        _response: PlatformResponse,
         _response_time_ms: u64,
     ) -> Result<AuctionResponse, Report<TrustedServerError>> {
         Err(Report::new(TrustedServerError::Auction {

crates/trusted-server-core/src/auction/README.md

@@ -24,7 +24,8 @@ The auction orchestration system allows you to:
                           ▼
 ┌─────────────────────────────────────────────────────────┐
 │              AuctionProvider Trait                       │
-│  - request_bids()                                        │
+│  - request_bids() async                                  │
+│  - parse_response()                                      │
 │  - provider_name()                                       │
 │  - timeout_ms()                                          │
 │  - is_enabled()                                          │
@@ -479,6 +480,7 @@ timeout_ms = 500
 use async_trait::async_trait;
 use crate::auction::provider::AuctionProvider;
 use crate::auction::types::{AuctionContext, AuctionRequest, AuctionResponse};
+use crate::platform::{PlatformPendingRequest, PlatformResponse};
 
 pub struct YourAuctionProvider {
     config: YourConfig,
@@ -494,11 +496,19 @@ impl AuctionProvider for YourAuctionProvider {
         &self,
         request: &AuctionRequest,
         _context: &AuctionContext<'_>,
-    ) -> Result<AuctionResponse, Report<TrustedServerError>> {
+    ) -> Result<PlatformPendingRequest, Report<TrustedServerError>> {
         // 1. Transform AuctionRequest to your provider's format
-        // 2. Make HTTP request to your provider
-        // 3. Parse response
-        // 4. Return AuctionResponse with bids
+        // 2. Launch HTTP request through services.http_client().send_async(...)
+        // 3. Return PlatformPendingRequest for the orchestrator to await
+        todo!()
+    }
+
+    async fn parse_response(
+        &self,
+        response: PlatformResponse,
+        response_time_ms: u64,
+    ) -> Result<AuctionResponse, Report<TrustedServerError>> {
+        // 4. Parse PlatformResponse into AuctionResponse
         todo!()
     }
 
@@ -534,7 +544,7 @@ let orchestrator = AuctionOrchestrator::new(config);
 orchestrator.register_provider(Arc::new(PrebidAuctionProvider::try_new(prebid_config)?));
 orchestrator.register_provider(Arc::new(ApsAuctionProvider::new(aps_config)));
 
-let result = orchestrator.run_auction(&request, &context).await?;
+let result = orchestrator.run_auction(&request, &context, &services).await?;
 
 // Check results
 assert_eq!(result.winning_bids.len(), 2);
@@ -543,7 +553,7 @@ assert!(result.total_time_ms < 2000);
 
 ## Performance Considerations
 
-- **Parallel Execution**: Currently runs sequentially in Fastly Compute (no tokio runtime), but structured for easy parallelization
+- **Parallel Execution**: Providers are launched concurrently via `select()` over `PendingRequest`s; responses are processed as they become ready within the auction deadline
 - **Timeouts**: Each provider has independent timeout; global timeout enforced at flow level
 - **Error Handling**: Provider failures don't fail entire auction; partial results returned
 

crates/trusted-server-core/src/auction/endpoints.rs

@@ -5,8 +5,6 @@ use error_stack::{Report, ResultExt};
 use http::{header, Request, Response, StatusCode};
 use serde_json::Value as JsonValue;
 
-use crate::compat;
-
 use crate::auction::formats::AdRequest;
 use crate::consent::gate_eids_by_consent;
 use crate::constants::COOKIE_TS_EIDS;
@@ -157,13 +155,10 @@ pub async fn handle_auction(
         log::warn!("Auction EIDs stripped by TCF consent gating");
     }
 
-    // Provider context only needs request metadata.
-    let fastly_req = compat::to_fastly_request_ref(&http_req);
-
     // Create auction context
     let context = AuctionContext {
         settings,
-        request: &fastly_req,
+        request: &http_req,
         timeout_ms: settings.auction.timeout_ms,
         provider_responses: None,
         services,

crates/trusted-server-core/src/auction/formats.rs

@@ -139,7 +139,7 @@ pub fn convert_tsjs_to_auction_request(
             .get(header::USER_AGENT)
             .and_then(|value| value.to_str().ok())
             .map(str::to_string),
-        ip: services.client_info.client_ip.map(|ip| ip.to_string()),
+        ip: services.client_info().client_ip.map(|ip| ip.to_string()),
         geo,
     });