diff --git a/crates/wasi-http/src/component_impl.rs b/crates/wasi-http/src/component_impl.rs
index de134c1a7e32..293184402b02 100644
--- a/crates/wasi-http/src/component_impl.rs
+++ b/crates/wasi-http/src/component_impl.rs
@@ -1,15 +1,15 @@
+use crate::default_outgoing_http::Host;
+pub use crate::r#struct::WasiHttp;
+use crate::streams::Host as StreamsHost;
+use crate::types::Host as TypesHost;
+use crate::types::Scheme;
 use std::str;
 use std::vec::Vec;
-use wasmtime::Caller;
-use wasmtime::AsContextMut;
 use wasmtime::AsContext;
-use wasmtime::Memory;
+use wasmtime::AsContextMut;
+use wasmtime::Caller;
 use wasmtime::Extern;
-use crate::default_outgoing_http::Host;
-use crate::types::Host as TypesHost;
-use crate::types::{Scheme};
-use crate::streams::Host as StreamsHost;
-pub use crate::r#struct::WasiHttp;
+use wasmtime::Memory;
 
 const MEMORY: &str = "memory";
 
@@ -64,11 +64,7 @@ fn slice_from_memory(
     Ok(buf)
 }
 
-fn u32_from_memory(
-    memory: &Memory,
-    ctx: impl AsContextMut,
-    ptr: u32,
-) -> Result<u32, HttpError> {
+fn u32_from_memory(memory: &Memory, ctx: impl AsContextMut, ptr: u32) -> Result<u32, HttpError> {
     let slice = slice_from_memory(memory, ctx, ptr, 4)?;
     let mut dst = [0u8; 4];
     dst.clone_from_slice(&slice[0..4]);
@@ -87,67 +83,72 @@ fn string_from_memory(
 }
 
 macro_rules! allocate_guest_pointer {
-    ($c:expr, $s:expr) => {
-        {
-            let realloc = $c.get_export("cabi_realloc").unwrap();
-            let func = realloc.into_func().unwrap();
-            let typed = func.typed::<(u32, u32, u32, u32), u32>($c.as_context()).unwrap();
-            typed.call($c.as_context_mut(), (0, 0, 0, $s)).unwrap()
-        }
-    }
+    ($c:expr, $s:expr) => {{
+        let realloc = $c.get_export("cabi_realloc").unwrap();
+        let func = realloc.into_func().unwrap();
+        let typed = func
+            .typed::<(u32, u32, u32, u32), u32>($c.as_context())
+            .unwrap();
+        typed.call($c.as_context_mut(), (0, 0, 0, $s)).unwrap()
+    }};
 }
 
 pub fn add_component_to_linker<T>(
     linker: &mut wasmtime::Linker<T>,
     get_cx: impl Fn(&mut T) -> &mut WasiHttp + Send + Sync + Copy + 'static,
-) -> anyhow::Result<()> 
-{
+) -> anyhow::Result<()> {
     linker.func_wrap(
         "default-outgoing-HTTP",
         "handle",
-        move |
-          mut caller: Caller<'_, T>,
-            request: u32,
-            _b: i32,
-            _c: i32,
-            _d: i32,
-            _e: i32,
-            _f: i32,
-            _g: i32,
-            _h: i32|
+        move |mut caller: Caller<'_, T>,
+              request: u32,
+              _b: i32,
+              _c: i32,
+              _d: i32,
+              _e: i32,
+              _f: i32,
+              _g: i32,
+              _h: i32|
               -> u32 {
             // TODO: use options here.
             get_cx(caller.data_mut()).handle(request, None).unwrap()
-        }
+        },
     )?;
     linker.func_wrap(
         "types",
         "new-outgoing-request",
-        move |
-          mut caller: Caller<'_, T>,
-            method: i32,
-            _b: i32,
-            _c: i32,
-            path_ptr: u32,
-            path_len: u32,
-            query_ptr: u32,
-            query_len: u32,
-            scheme_is_some: i32,
-            scheme: i32,
-            _h: i32,
-            _i: i32,
-            authority_ptr: u32,
-            authority_len: u32,
-            headers: u32|
-                  -> u32 {
+        move |mut caller: Caller<'_, T>,
+              method: i32,
+              _b: i32,
+              _c: i32,
+              path_ptr: u32,
+              path_len: u32,
+              query_ptr: u32,
+              query_len: u32,
+              scheme_is_some: i32,
+              scheme: i32,
+              _h: i32,
+              _i: i32,
+              authority_ptr: u32,
+              authority_len: u32,
+              headers: u32|
+              -> u32 {
             let memory = match memory_get(&mut caller) {
                 Ok(m) => m,
                 Err(e) => return e.into(),
             };
-            let path = string_from_memory(&memory, caller.as_context_mut(), path_ptr, path_len).unwrap();
-            let query = string_from_memory(&memory, caller.as_context_mut(), query_ptr, query_len).unwrap();
-            let authority = string_from_memory(&memory, caller.as_context_mut(), authority_ptr, authority_len).unwrap();
-            
+            let path =
+                string_from_memory(&memory, caller.as_context_mut(), path_ptr, path_len).unwrap();
+            let query =
+                string_from_memory(&memory, caller.as_context_mut(), query_ptr, query_len).unwrap();
+            let authority = string_from_memory(
+                &memory,
+                caller.as_context_mut(),
+                authority_ptr,
+                authority_len,
+            )
+            .unwrap();
+
             let mut s = Scheme::Https;
             if scheme_is_some == 1 {
                 s = match scheme {
@@ -170,29 +171,24 @@ pub fn add_component_to_linker<T>(
             };
 
             let ctx = get_cx(caller.data_mut());
-            ctx.new_outgoing_request(m, path, query, Some(s), authority, headers).unwrap()
-        }
+            ctx.new_outgoing_request(m, path, query, Some(s), authority, headers)
+                .unwrap()
+        },
     )?;
     linker.func_wrap(
         "types",
         "incoming-response-status",
-        move |
-          mut caller: Caller<'_, T>,
-          id: u32|
-              -> u32 {
+        move |mut caller: Caller<'_, T>, id: u32| -> u32 {
             let ctx = get_cx(caller.data_mut());
             ctx.incoming_response_status(id).unwrap().into()
-        }
+        },
     )?;
     linker.func_wrap(
         "types",
         "future-incoming-response-get",
-        move |
-          mut caller: Caller<'_, T>,
-          future: u32,
-          ptr: i32| {
+        move |mut caller: Caller<'_, T>, future: u32, ptr: i32| {
             let memory = memory_get(&mut caller).unwrap();
-            
+
             // First == is_some
             // Second == is_err
             // Third == {ok: is_err = false, tag: is_err = true}
@@ -201,20 +197,15 @@ pub fn add_component_to_linker<T>(
             let result: [u32; 5] = [1, 0, future, 0, 0];
             let raw: [u8; 20] = unsafe { std::mem::transmute(result) };
 
-            memory.write(
-                caller.as_context_mut(),
-                ptr as _,
-                &raw,
-            ).unwrap();
-        }
+            memory
+                .write(caller.as_context_mut(), ptr as _, &raw)
+                .unwrap();
+        },
     )?;
     linker.func_wrap(
         "types",
         "incoming-response-consume",
-        move |
-          mut caller: Caller<'_, T>,
-          response: u32,
-          ptr: i32| {
+        move |mut caller: Caller<'_, T>, response: u32, ptr: i32| {
             let memory = memory_get(&mut caller).unwrap();
 
             // First == is_some
@@ -222,206 +213,170 @@ pub fn add_component_to_linker<T>(
             let result: [u32; 2] = [0, response];
             let raw: [u8; 8] = unsafe { std::mem::transmute(result) };
 
-            memory.write(
-                caller.as_context_mut(),
-                ptr as _,
-                &raw,
-            ).unwrap();
-        }
+            memory
+                .write(caller.as_context_mut(), ptr as _, &raw)
+                .unwrap();
+        },
     )?;
     linker.func_wrap(
         "streams",
         "read-into",
-        move |
-          mut caller: Caller<'_, T>,
-          stream: u32,
-          ptr: u32,
-          _len: u32| -> i32 {
+        move |mut caller: Caller<'_, T>, stream: u32, ptr: u32, _len: u32| -> i32 {
             let memory = memory_get(&mut caller).unwrap();
             let ctx = get_cx(caller.data_mut());
             let response = ctx.responses.get(&stream).unwrap();
             let bytes = response.body.clone();
 
-            memory.write(
-                caller.as_context_mut(),
-                ptr as _,
-                &bytes,
-            ).unwrap();
+            memory
+                .write(caller.as_context_mut(), ptr as _, &bytes)
+                .unwrap();
             bytes.len().try_into().unwrap()
-        }
+        },
     )?;
     linker.func_wrap(
         "poll",
         "drop-pollable",
-        move |
-          _caller: Caller<'_, T>,
-          _a: i32|
-    {})?;
+        move |_caller: Caller<'_, T>, _a: i32| {},
+    )?;
     linker.func_wrap(
         "types",
         "drop-fields",
-        move |
-          mut caller: Caller<'_, T>,
-          ptr: u32|
-    {
-        let ctx = get_cx(caller.data_mut());
-        ctx.drop_fields(ptr)
-    })?;
+        move |mut caller: Caller<'_, T>, ptr: u32| {
+            let ctx = get_cx(caller.data_mut());
+            ctx.drop_fields(ptr)
+        },
+    )?;
     linker.func_wrap(
         "streams",
         "drop-input-stream",
-        move |
-          mut caller: Caller<'_, T>,
-          id: u32|
-    {
-        let ctx = get_cx(caller.data_mut());
-        ctx.responses.get_mut(&id).unwrap().body.truncate(0);
-    })?;
+        move |mut caller: Caller<'_, T>, id: u32| {
+            let ctx = get_cx(caller.data_mut());
+            ctx.responses.get_mut(&id).unwrap().body.truncate(0);
+        },
+    )?;
     linker.func_wrap(
         "types",
         "drop-outgoing-request",
-        move |
-          mut caller: Caller<'_, T>,
-          id: u32|
-    {
-        let ctx = get_cx(caller.data_mut());
-        ctx.drop_outgoing_request(id).unwrap();
-    })?;
+        move |mut caller: Caller<'_, T>, id: u32| {
+            let ctx = get_cx(caller.data_mut());
+            ctx.drop_outgoing_request(id).unwrap();
+        },
+    )?;
     linker.func_wrap(
         "types",
         "drop-incoming-response",
-        move |
-          mut caller: Caller<'_, T>,
-          id: u32|
-    {
-        let ctx = get_cx(caller.data_mut());
-        ctx.drop_incoming_response(id).unwrap()
-    })?;
+        move |mut caller: Caller<'_, T>, id: u32| {
+            let ctx = get_cx(caller.data_mut());
+            ctx.drop_incoming_response(id).unwrap()
+        },
+    )?;
     linker.func_wrap(
         "types",
         "new-fields",
-        move |
-          mut caller: Caller<'_, T>,
-          base_ptr: u32,
-          len: u32|
-    -> u32
-    {
-        let memory = memory_get(&mut caller).unwrap();
+        move |mut caller: Caller<'_, T>, base_ptr: u32, len: u32| -> u32 {
+            let memory = memory_get(&mut caller).unwrap();
 
-        let mut vec = Vec::new();
-        let mut i = 0;
-        // TODO: read this more efficiently as a single block.
-        while i < len {
-            let ptr = base_ptr + i * 16;
-            let name_ptr = u32_from_memory(&memory, caller.as_context_mut(), ptr).unwrap();
-            let name_len = u32_from_memory(&memory, caller.as_context_mut(), ptr + 4).unwrap();
-            let value_ptr = u32_from_memory(&memory, caller.as_context_mut(), ptr + 8).unwrap();
-            let value_len = u32_from_memory(&memory, caller.as_context_mut(), ptr + 12).unwrap();
+            let mut vec = Vec::new();
+            let mut i = 0;
+            // TODO: read this more efficiently as a single block.
+            while i < len {
+                let ptr = base_ptr + i * 16;
+                let name_ptr = u32_from_memory(&memory, caller.as_context_mut(), ptr).unwrap();
+                let name_len = u32_from_memory(&memory, caller.as_context_mut(), ptr + 4).unwrap();
+                let value_ptr = u32_from_memory(&memory, caller.as_context_mut(), ptr + 8).unwrap();
+                let value_len =
+                    u32_from_memory(&memory, caller.as_context_mut(), ptr + 12).unwrap();
 
-            let name = string_from_memory(&memory, caller.as_context_mut(), name_ptr, name_len).unwrap();
-            let value = string_from_memory(&memory, caller.as_context_mut(), value_ptr, value_len).unwrap();
+                let name = string_from_memory(&memory, caller.as_context_mut(), name_ptr, name_len)
+                    .unwrap();
+                let value =
+                    string_from_memory(&memory, caller.as_context_mut(), value_ptr, value_len)
+                        .unwrap();
 
-            vec.push((name, value));
-            i = i + 1;
-        }
+                vec.push((name, value));
+                i = i + 1;
+            }
 
-        let ctx = get_cx(caller.data_mut());
-        ctx.new_fields(vec).unwrap()
-    })?;
+            let ctx = get_cx(caller.data_mut());
+            ctx.new_fields(vec).unwrap()
+        },
+    )?;
     linker.func_wrap(
         "streams",
         "read",
-        move |
-          mut caller: Caller<'_, T>,
-          stream: u32,
-          len: u64,
-          ptr: u32|
-    {
-        let ctx = get_cx(caller.data_mut());
-        let bytes_tuple = ctx.read(stream, len).unwrap().unwrap();
-        let bytes = bytes_tuple.0;
-        let done = match bytes_tuple.1 { true => 1, false => 0 };
-        let body_len: u32 = bytes.len().try_into().unwrap();
-        let out_ptr = allocate_guest_pointer!(caller, body_len);
-        let result: [u32; 4] = [0, out_ptr, body_len, done];
-        let raw: [u8; 16] = unsafe { std::mem::transmute(result) };
-        
-        let memory = memory_get(&mut caller).unwrap();
-        memory.write(
-            caller.as_context_mut(),
-            out_ptr as _,
-            &bytes,
-        ).unwrap();
-        memory.write(
-            caller.as_context_mut(),
-            ptr as _,
-            &raw,
-        ).unwrap();
-    })?;
+        move |mut caller: Caller<'_, T>, stream: u32, len: u64, ptr: u32| {
+            let ctx = get_cx(caller.data_mut());
+            let bytes_tuple = ctx.read(stream, len).unwrap().unwrap();
+            let bytes = bytes_tuple.0;
+            let done = match bytes_tuple.1 {
+                true => 1,
+                false => 0,
+            };
+            let body_len: u32 = bytes.len().try_into().unwrap();
+            let out_ptr = allocate_guest_pointer!(caller, body_len);
+            let result: [u32; 4] = [0, out_ptr, body_len, done];
+            let raw: [u8; 16] = unsafe { std::mem::transmute(result) };
+
+            let memory = memory_get(&mut caller).unwrap();
+            memory
+                .write(caller.as_context_mut(), out_ptr as _, &bytes)
+                .unwrap();
+            memory
+                .write(caller.as_context_mut(), ptr as _, &raw)
+                .unwrap();
+        },
+    )?;
     linker.func_wrap(
         "types",
         "fields-entries",
-        move |
-          mut caller: Caller<'_, T>,
-          fields: u32,
-          out_ptr: u32|
-    {
-        let ctx = get_cx(caller.data_mut());
-        let entries = ctx.fields_entries(fields).unwrap();
+        move |mut caller: Caller<'_, T>, fields: u32, out_ptr: u32| {
+            let ctx = get_cx(caller.data_mut());
+            let entries = ctx.fields_entries(fields).unwrap();
 
-        let header_len = entries.len();
-        let tuple_ptr = allocate_guest_pointer!(caller, (16 * header_len).try_into().unwrap());
-        let mut ptr = tuple_ptr;
-        for item in entries.iter() {
-            let name = &item.0;
-            let value = &item.1;
-            let name_len: u32 = name.len().try_into().unwrap();
-            let value_len: u32 = value.len().try_into().unwrap();
-        
-            let name_ptr = allocate_guest_pointer!(caller, name_len);
-            let value_ptr = allocate_guest_pointer!(caller, value_len);   
+            let header_len = entries.len();
+            let tuple_ptr = allocate_guest_pointer!(caller, (16 * header_len).try_into().unwrap());
+            let mut ptr = tuple_ptr;
+            for item in entries.iter() {
+                let name = &item.0;
+                let value = &item.1;
+                let name_len: u32 = name.len().try_into().unwrap();
+                let value_len: u32 = value.len().try_into().unwrap();
 
-            let memory = memory_get(&mut caller).unwrap();
-            memory.write(
-                caller.as_context_mut(),
-                name_ptr as _,
-                &name.as_bytes(),
-            ).unwrap();
-            memory.write(
-                caller.as_context_mut(),
-                value_ptr as _,
-                &value.as_bytes(),
-            ).unwrap();
+                let name_ptr = allocate_guest_pointer!(caller, name_len);
+                let value_ptr = allocate_guest_pointer!(caller, value_len);
 
-            let pair: [u32; 4] = [name_ptr, name_len, value_ptr, value_len];
-            let raw_pair: [u8; 16] = unsafe { std::mem::transmute(pair) };
-            memory.write(
-                caller.as_context_mut(),
-                ptr as _,
-                &raw_pair,
-            ).unwrap();
+                let memory = memory_get(&mut caller).unwrap();
+                memory
+                    .write(caller.as_context_mut(), name_ptr as _, &name.as_bytes())
+                    .unwrap();
+                memory
+                    .write(caller.as_context_mut(), value_ptr as _, &value.as_bytes())
+                    .unwrap();
 
-            ptr = ptr + 16;
-        }
-        
-        let memory = memory_get(&mut caller).unwrap();
-        let result: [u32; 2] = [tuple_ptr, header_len.try_into().unwrap()];
-        let raw: [u8; 8] = unsafe { std::mem::transmute(result) };
-        memory.write(
-            caller.as_context_mut(),
-            out_ptr as _,
-            &raw,
-        ).unwrap();
-    })?;
+                let pair: [u32; 4] = [name_ptr, name_len, value_ptr, value_len];
+                let raw_pair: [u8; 16] = unsafe { std::mem::transmute(pair) };
+                memory
+                    .write(caller.as_context_mut(), ptr as _, &raw_pair)
+                    .unwrap();
+
+                ptr = ptr + 16;
+            }
+
+            let memory = memory_get(&mut caller).unwrap();
+            let result: [u32; 2] = [tuple_ptr, header_len.try_into().unwrap()];
+            let raw: [u8; 8] = unsafe { std::mem::transmute(result) };
+            memory
+                .write(caller.as_context_mut(), out_ptr as _, &raw)
+                .unwrap();
+        },
+    )?;
     linker.func_wrap(
         "types",
         "incoming-response-headers",
-        move |
-          mut caller: Caller<'_, T>,
-          handle: u32|
-          -> u32 {
+        move |mut caller: Caller<'_, T>, handle: u32| -> u32 {
             let ctx = get_cx(caller.data_mut());
             ctx.incoming_response_headers(handle).unwrap()
-          })?;
+        },
+    )?;
     Ok(())
-}
\ No newline at end of file
+}
diff --git a/crates/wasi-http/src/http_impl.rs b/crates/wasi-http/src/http_impl.rs
index d1d13e8f6bd2..fdb1439e512b 100644
--- a/crates/wasi-http/src/http_impl.rs
+++ b/crates/wasi-http/src/http_impl.rs
@@ -1,7 +1,7 @@
-use reqwest::Method;
-use crate::types::Scheme;
 use crate::r#struct::ActiveResponse;
 pub use crate::r#struct::WasiHttp;
+use crate::types::Scheme;
+use reqwest::Method;
 
 impl crate::default_outgoing_http::Host for WasiHttp {
     fn handle(
@@ -32,13 +32,15 @@ impl crate::default_outgoing_http::Host for WasiHttp {
                     // TODO: this is wrong, fix this.
                     _ => panic!("Unsupported scheme!"),
                 }
-            },
-            None => "https://"
+            }
+            None => "https://",
         };
 
-        let mut call = reqwest::blocking::Client::new()
-            .request(method, scheme.to_owned() + &request.authority + &request.path + &request.query);
-        
+        let mut call = reqwest::blocking::Client::new().request(
+            method,
+            scheme.to_owned() + &request.authority + &request.path + &request.query,
+        );
+
         for (key, val) in request.headers.iter() {
             for item in val {
                 call = call.header(key, item.clone());
@@ -52,8 +54,10 @@ impl crate::default_outgoing_http::Host for WasiHttp {
         response.status = res.status().try_into()?;
         for (key, value) in res.headers().iter() {
             let mut vec = std::vec::Vec::new();
-            vec.push( value.to_str()?.to_string());
-            response.response_headers.insert(key.as_str().to_string(), vec);
+            vec.push(value.to_str()?.to_string());
+            response
+                .response_headers
+                .insert(key.as_str().to_string(), vec);
         }
         response.body = res.bytes()?;
         self.responses.insert(response_id, response);
diff --git a/crates/wasi-http/src/lib.rs b/crates/wasi-http/src/lib.rs
index 7a0125b4b12d..eef1cc57aa54 100644
--- a/crates/wasi-http/src/lib.rs
+++ b/crates/wasi-http/src/lib.rs
@@ -3,11 +3,11 @@ pub use crate::r#struct::WasiHttp;
 
 wasmtime::component::bindgen!("proxy");
 
-pub mod r#struct;
-pub mod types_impl;
-pub mod streams_impl;
 pub mod component_impl;
 pub mod http_impl;
+pub mod streams_impl;
+pub mod r#struct;
+pub mod types_impl;
 
 pub fn add_to_component_linker<T>(
     linker: &mut wasmtime::component::Linker<T>,
diff --git a/crates/wasi-http/src/streams_impl.rs b/crates/wasi-http/src/streams_impl.rs
index 25ebb005c76f..56d194c084d6 100644
--- a/crates/wasi-http/src/streams_impl.rs
+++ b/crates/wasi-http/src/streams_impl.rs
@@ -1,61 +1,73 @@
-use crate::streams::{InputStream, OutputStream, StreamError};
 use crate::poll::Pollable;
+use crate::streams::{InputStream, OutputStream, StreamError};
 use crate::WasiHttp;
 use std::vec::Vec;
 
 impl crate::streams::Host for WasiHttp {
-        fn read(
-            &mut self,
-            stream: InputStream,
-            _len: u64,
-        ) -> wasmtime::Result<Result<(Vec<u8>, bool), StreamError>> {
-            let response = self.responses.get(&stream).unwrap();
-            let bytes = response.body.clone();
-            Ok(Ok((bytes.to_vec(), true)))
-        }
- 
-        fn skip(
-            &mut self,
-            _this: InputStream,
-            _len: u64,
-        ) -> wasmtime::Result<Result<(u64, bool), StreamError>> { todo!(); }
- 
-        fn subscribe_to_input_stream(
-            &mut self,
-            _this: InputStream,
-        ) -> wasmtime::Result<Pollable> { todo!(); }
- 
-        fn drop_input_stream(&mut self, _this: InputStream) -> wasmtime::Result<()> { todo!(); }
- 
-        fn write(
-            &mut self,
-            _this: OutputStream,
-            _buf: Vec<u8>,
-        ) -> wasmtime::Result<Result<u64, StreamError>> { todo!(); }
- 
-        fn write_zeroes(
-            &mut self,
-            _this: OutputStream,
-            _len: u64,
-        ) -> wasmtime::Result<Result<u64, StreamError>> { todo!(); }
- 
-        fn splice(
-            &mut self,
-            _this: OutputStream,
-            _src: InputStream,
-            _len: u64,
-        ) -> wasmtime::Result<Result<(u64, bool), StreamError>> { todo!(); }
-    
-        fn forward(
-            &mut self,
-            _this: OutputStream,
-            _src: InputStream,
-        ) -> wasmtime::Result<Result<u64, StreamError>> { todo!(); }
- 
-        fn subscribe_to_output_stream(
-            &mut self,
-            _this: OutputStream,
-        ) -> wasmtime::Result<Pollable> { todo!(); }
- 
-        fn drop_output_stream(&mut self, _this: OutputStream) -> wasmtime::Result<()> { todo!(); }
-}
\ No newline at end of file
+    fn read(
+        &mut self,
+        stream: InputStream,
+        _len: u64,
+    ) -> wasmtime::Result<Result<(Vec<u8>, bool), StreamError>> {
+        let response = self.responses.get(&stream).unwrap();
+        let bytes = response.body.clone();
+        Ok(Ok((bytes.to_vec(), true)))
+    }
+
+    fn skip(
+        &mut self,
+        _this: InputStream,
+        _len: u64,
+    ) -> wasmtime::Result<Result<(u64, bool), StreamError>> {
+        todo!();
+    }
+
+    fn subscribe_to_input_stream(&mut self, _this: InputStream) -> wasmtime::Result<Pollable> {
+        todo!();
+    }
+
+    fn drop_input_stream(&mut self, _this: InputStream) -> wasmtime::Result<()> {
+        todo!();
+    }
+
+    fn write(
+        &mut self,
+        _this: OutputStream,
+        _buf: Vec<u8>,
+    ) -> wasmtime::Result<Result<u64, StreamError>> {
+        todo!();
+    }
+
+    fn write_zeroes(
+        &mut self,
+        _this: OutputStream,
+        _len: u64,
+    ) -> wasmtime::Result<Result<u64, StreamError>> {
+        todo!();
+    }
+
+    fn splice(
+        &mut self,
+        _this: OutputStream,
+        _src: InputStream,
+        _len: u64,
+    ) -> wasmtime::Result<Result<(u64, bool), StreamError>> {
+        todo!();
+    }
+
+    fn forward(
+        &mut self,
+        _this: OutputStream,
+        _src: InputStream,
+    ) -> wasmtime::Result<Result<u64, StreamError>> {
+        todo!();
+    }
+
+    fn subscribe_to_output_stream(&mut self, _this: OutputStream) -> wasmtime::Result<Pollable> {
+        todo!();
+    }
+
+    fn drop_output_stream(&mut self, _this: OutputStream) -> wasmtime::Result<()> {
+        todo!();
+    }
+}
diff --git a/crates/wasi-http/src/struct.rs b/crates/wasi-http/src/struct.rs
index 22b491a8a235..f580575d30d7 100644
--- a/crates/wasi-http/src/struct.rs
+++ b/crates/wasi-http/src/struct.rs
@@ -34,7 +34,7 @@ pub struct ActiveResponse {
 }
 
 impl ActiveRequest {
-    pub fn new(id: u32) -> Self {        
+    pub fn new(id: u32) -> Self {
         Self {
             id: id,
             active_request: false,
diff --git a/crates/wasi-http/src/types_impl.rs b/crates/wasi-http/src/types_impl.rs
index 3b38cf5ee4ac..5ba2325d807a 100644
--- a/crates/wasi-http/src/types_impl.rs
+++ b/crates/wasi-http/src/types_impl.rs
@@ -1,18 +1,19 @@
-use crate::types::{Method, ResponseOutparam, Fields, Trailers, Scheme, Error, IncomingRequest, FutureIncomingResponse, IncomingResponse, OutgoingStream, OutgoingResponse, OutgoingRequest, Headers, StatusCode, IncomingStream};
-use crate::poll:: Pollable;
+use crate::poll::Pollable;
+use crate::r#struct::ActiveRequest;
+use crate::types::{
+    Error, Fields, FutureIncomingResponse, Headers, IncomingRequest, IncomingResponse,
+    IncomingStream, Method, OutgoingRequest, OutgoingResponse, OutgoingStream, ResponseOutparam,
+    Scheme, StatusCode, Trailers,
+};
 use crate::WasiHttp;
 use std::collections::HashMap;
-use crate::r#struct::ActiveRequest;
 
 impl crate::types::Host for WasiHttp {
     fn drop_fields(&mut self, fields: Fields) -> wasmtime::Result<()> {
         self.fields.remove(&fields);
         Ok(())
     }
-    fn new_fields(
-        &mut self,
-        entries: Vec<(String, String)>,
-    ) -> wasmtime::Result<Fields> {
+    fn new_fields(&mut self, entries: Vec<(String, String)>) -> wasmtime::Result<Fields> {
         let mut map = HashMap::new();
         for item in entries.iter() {
             let mut vec = std::vec::Vec::new();
@@ -26,16 +27,11 @@ impl crate::types::Host for WasiHttp {
 
         Ok(id)
     }
-    fn fields_get(
-        &mut self,
-        fields: Fields,
-        name: String,
-    ) -> wasmtime::Result<Vec<String>> {
-        let res = 
-            match self.fields.get(&fields) {
-                Some(m) => m.get(&name).unwrap().clone(),
-                None => panic!("not found"),
-            };
+    fn fields_get(&mut self, fields: Fields, name: String) -> wasmtime::Result<Vec<String>> {
+        let res = match self.fields.get(&fields) {
+            Some(m) => m.get(&name).unwrap().clone(),
+            None => panic!("not found"),
+        };
         Ok(res)
     }
     fn fields_set(
@@ -46,18 +42,14 @@ impl crate::types::Host for WasiHttp {
     ) -> wasmtime::Result<()> {
         match self.fields.get_mut(&fields) {
             Some(m) => m.insert(name, value.clone()),
-            None => None
+            None => None,
         };
         Ok(())
     }
-    fn fields_delete(
-        &mut self,
-        fields: Fields,
-        name: String,
-    ) -> wasmtime::Result<()> {
+    fn fields_delete(&mut self, fields: Fields, name: String) -> wasmtime::Result<()> {
         match self.fields.get_mut(&fields) {
             Some(m) => m.remove(&name),
-            None => None
+            None => None,
         };
         Ok(())
     }
@@ -68,24 +60,19 @@ impl crate::types::Host for WasiHttp {
         value: String,
     ) -> wasmtime::Result<()> {
         match self.fields.get_mut(&fields) {
-            Some(m) => {
-                match m.get_mut(&name) {
-                    Some(v) => v.push(value),
-                    None => {
-                        let mut vec = std::vec::Vec::new();
-                        vec.push(value);
-                        m.insert(name, vec);
-                    }
+            Some(m) => match m.get_mut(&name) {
+                Some(v) => v.push(value),
+                None => {
+                    let mut vec = std::vec::Vec::new();
+                    vec.push(value);
+                    m.insert(name, vec);
                 }
             },
             None => panic!("Unknown fields!"),
         }
         Ok(())
     }
-    fn fields_entries(
-        &mut self,
-        fields: Fields,
-    ) -> wasmtime::Result<Vec<(String, String)>> {
+    fn fields_entries(&mut self, fields: Fields) -> wasmtime::Result<Vec<(String, String)>> {
         let field_map = self.fields.get(&fields).unwrap();
         let mut result = Vec::new();
         for (name, value) in field_map {
@@ -96,63 +83,62 @@ impl crate::types::Host for WasiHttp {
     fn fields_clone(&mut self, fields: Fields) -> wasmtime::Result<Fields> {
         let id = self.fields_id_base;
         self.fields_id_base = self.fields_id_base + 1;
-        
+
         match self.fields.get(&fields) {
             Some(m) => {
                 self.fields.insert(id, m.clone());
-            },
+            }
             None => {}
         }
         Ok(id)
     }
-    fn finish_incoming_stream(
-        &mut self,
-        _s: IncomingStream,
-    ) -> wasmtime::Result<Option<Trailers>> { todo!() }
+    fn finish_incoming_stream(&mut self, _s: IncomingStream) -> wasmtime::Result<Option<Trailers>> {
+        todo!()
+    }
     fn finish_outgoing_stream(
         &mut self,
         _s: OutgoingStream,
         _trailers: Option<Trailers>,
-    ) -> wasmtime::Result<()> { todo!() }
-    fn drop_incoming_request(
-        &mut self,
-        _request: IncomingRequest,
-    ) -> wasmtime::Result<()> { todo!() }
-    fn drop_outgoing_request(
-        &mut self,
-        request: OutgoingRequest,
     ) -> wasmtime::Result<()> {
+        todo!()
+    }
+    fn drop_incoming_request(&mut self, _request: IncomingRequest) -> wasmtime::Result<()> {
+        todo!()
+    }
+    fn drop_outgoing_request(&mut self, request: OutgoingRequest) -> wasmtime::Result<()> {
         self.requests.remove(&request);
         Ok(())
     }
-    fn incoming_request_method(
-        &mut self,
-        _request: IncomingRequest,
-    ) -> wasmtime::Result<Method> { todo!() }
-    fn incoming_request_path(
-        &mut self,
-        _request: IncomingRequest,
-    ) -> wasmtime::Result<String> { todo!() }
+    fn incoming_request_method(&mut self, _request: IncomingRequest) -> wasmtime::Result<Method> {
+        todo!()
+    }
+    fn incoming_request_path(&mut self, _request: IncomingRequest) -> wasmtime::Result<String> {
+        todo!()
+    }
     fn incoming_request_scheme(
         &mut self,
         _request: IncomingRequest,
-    ) -> wasmtime::Result<Option<Scheme>> { todo!() }
+    ) -> wasmtime::Result<Option<Scheme>> {
+        todo!()
+    }
     fn incoming_request_authority(
         &mut self,
         _request: IncomingRequest,
-    ) -> wasmtime::Result<String> { todo!() }
-    fn incoming_request_headers(
-        &mut self,
-        _request: IncomingRequest,
-    ) -> wasmtime::Result<Headers> { todo!() }
+    ) -> wasmtime::Result<String> {
+        todo!()
+    }
+    fn incoming_request_headers(&mut self, _request: IncomingRequest) -> wasmtime::Result<Headers> {
+        todo!()
+    }
     fn incoming_request_consume(
         &mut self,
         _request: IncomingRequest,
-    ) -> wasmtime::Result<Result<IncomingStream, ()>> { todo!() }
-    fn incoming_request_query(
-        &mut self,
-        _request: IncomingRequest,
-    ) -> wasmtime::Result<String> { todo!() }
+    ) -> wasmtime::Result<Result<IncomingStream, ()>> {
+        todo!()
+    }
+    fn incoming_request_query(&mut self, _request: IncomingRequest) -> wasmtime::Result<String> {
+        todo!()
+    }
     fn new_outgoing_request(
         &mut self,
         method: Method,
@@ -178,26 +164,25 @@ impl crate::types::Host for WasiHttp {
     fn outgoing_request_write(
         &mut self,
         _request: OutgoingRequest,
-    ) -> wasmtime::Result<Result<OutgoingStream, ()>> { todo!() }
-    fn drop_response_outparam(
-        &mut self,
-        _response: ResponseOutparam,
-    ) -> wasmtime::Result<()> { todo!() }
+    ) -> wasmtime::Result<Result<OutgoingStream, ()>> {
+        todo!()
+    }
+    fn drop_response_outparam(&mut self, _response: ResponseOutparam) -> wasmtime::Result<()> {
+        todo!()
+    }
     fn set_response_outparam(
         &mut self,
         _response: Result<OutgoingResponse, Error>,
-    ) -> wasmtime::Result<Result<(), ()>> { todo!() }
-    fn drop_incoming_response(
-        &mut self,
-        response: IncomingResponse,
-    ) -> wasmtime::Result<()> {
+    ) -> wasmtime::Result<Result<(), ()>> {
+        todo!()
+    }
+    fn drop_incoming_response(&mut self, response: IncomingResponse) -> wasmtime::Result<()> {
         self.responses.remove(&response);
         Ok(())
     }
-    fn drop_outgoing_response(
-        &mut self,
-        _response: OutgoingResponse,
-    ) -> wasmtime::Result<()> { todo!() }
+    fn drop_outgoing_response(&mut self, _response: OutgoingResponse) -> wasmtime::Result<()> {
+        todo!()
+    }
     fn incoming_response_status(
         &mut self,
         response: IncomingResponse,
@@ -211,33 +196,50 @@ impl crate::types::Host for WasiHttp {
         let id = self.fields_id_base;
         self.fields_id_base = self.fields_id_base + 1;
 
-        let headers = self.responses.get(&response).unwrap().response_headers.clone();
+        let headers = self
+            .responses
+            .get(&response)
+            .unwrap()
+            .response_headers
+            .clone();
         self.fields.insert(id, headers);
         Ok(id)
     }
     fn incoming_response_consume(
         &mut self,
         _response: IncomingResponse,
-    ) -> wasmtime::Result<Result<IncomingStream, ()>> { todo!() }
+    ) -> wasmtime::Result<Result<IncomingStream, ()>> {
+        todo!()
+    }
     fn new_outgoing_response(
         &mut self,
         _status_code: StatusCode,
         _headers: Headers,
-    ) -> wasmtime::Result<OutgoingResponse> { todo!() }
+    ) -> wasmtime::Result<OutgoingResponse> {
+        todo!()
+    }
     fn outgoing_response_write(
         &mut self,
         _response: OutgoingResponse,
-    ) -> wasmtime::Result<Result<OutgoingStream, ()>> { todo!() }
+    ) -> wasmtime::Result<Result<OutgoingStream, ()>> {
+        todo!()
+    }
     fn drop_future_incoming_response(
         &mut self,
         _f: FutureIncomingResponse,
-    ) -> wasmtime::Result<()> { todo!() }
+    ) -> wasmtime::Result<()> {
+        todo!()
+    }
     fn future_incoming_response_get(
         &mut self,
         _f: FutureIncomingResponse,
-    ) -> wasmtime::Result<Option<Result<IncomingResponse, Error>>> { todo!() }
+    ) -> wasmtime::Result<Option<Result<IncomingResponse, Error>>> {
+        todo!()
+    }
     fn listen_to_future_incoming_response(
         &mut self,
         _f: FutureIncomingResponse,
-    ) -> wasmtime::Result<Pollable> { todo!() }
+    ) -> wasmtime::Result<Pollable> {
+        todo!()
+    }
 }
diff --git a/src/commands/run.rs b/src/commands/run.rs
index c147eb29244a..f9aaca631d99 100644
--- a/src/commands/run.rs
+++ b/src/commands/run.rs
@@ -563,9 +563,7 @@ fn populate_with_wasi(
 
     if wasi_modules.wasi_http {
         let w_http = WasiHttp::new();
-        wasi_http::add_to_linker(linker, |host: &mut Host| {
-            host.wasi_http.as_mut().unwrap()
-        })?;
+        wasi_http::add_to_linker(linker, |host: &mut Host| host.wasi_http.as_mut().unwrap())?;
         store.data_mut().wasi_http = Some(w_http);
     }