Encode parameter values in http path and ... (#395)

* Encode parameter values in http path and ...

- don't send param values in request body in http get request
- send param values in http post request

* rust tests

* refactor code

* add tests

crates/prompt_gateway/src/stream_context.rs

@@ -1,4 +1,5 @@
 use crate::metrics::Metrics;
+use crate::tools::compute_request_path_body;
 use common::api::open_ai::{
     to_server_events, ArchState, ChatCompletionStreamResponse, ChatCompletionsRequest,
     ChatCompletionsResponse, Message, ModelServerResponse, ToolCall,
@@ -16,7 +17,6 @@ use derivative::Derivative;
 use http::StatusCode;
 use log::{debug, trace, warn};
 use proxy_wasm::traits::*;
-use serde_yaml::Value;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -273,84 +273,70 @@ impl StreamContext {
 
     fn schedule_api_call_request(&mut self, mut callout_context: StreamCallContext) {
         let tools_call_name = self.tool_calls.as_ref().unwrap()[0].function.name.clone();
+        let prompt_target = self.prompt_targets.get(&tools_call_name).unwrap();
+        let tool_params = &self.tool_calls.as_ref().unwrap()[0].function.arguments;
+        let endpoint_details = prompt_target.endpoint.as_ref().unwrap();
+        let endpoint_path: String = endpoint_details
+            .path
+            .as_ref()
+            .unwrap_or(&String::from("/"))
+            .to_string();
 
-        let prompt_target = self.prompt_targets.get(&tools_call_name).unwrap().clone();
+        let http_method = endpoint_details.method.clone().unwrap_or_default();
+        let prompt_target_params = prompt_target.parameters.clone().unwrap_or_default();
 
-        let mut tool_params = self.tool_calls.as_ref().unwrap()[0]
-            .function
-            .arguments
-            .clone();
-        tool_params.insert(
-            String::from(MESSAGES_KEY),
-            serde_yaml::to_value(&callout_context.request_body.messages).unwrap(),
-        );
-
-        let tool_params_json_str = serde_json::to_string(&tool_params).unwrap();
-
-        let endpoint = prompt_target.endpoint.unwrap();
-        let path: String = endpoint.path.unwrap_or(String::from("/"));
-
-        // only add params that are of string, number and bool type
-        let url_params = tool_params
-            .iter()
-            .filter(|(_, value)| value.is_number() || value.is_string() || value.is_bool())
-            .map(|(key, value)| match value {
-                Value::Number(n) => (key.clone(), n.to_string()),
-                Value::String(s) => (key.clone(), s.clone()),
-                Value::Bool(b) => (key.clone(), b.to_string()),
-                Value::Null => todo!(),
-                Value::Sequence(_) => todo!(),
-                Value::Mapping(_) => todo!(),
-                Value::Tagged(_) => todo!(),
-            })
-            .collect::<HashMap<String, String>>();
-
-        let path = match common::path::replace_params_in_path(&path, &url_params) {
-            Ok(path) => path,
+        let (path, body) = match compute_request_path_body(
+            &endpoint_path,
+            tool_params,
+            &prompt_target_params,
+            &http_method,
+        ) {
+            Ok((path, body)) => (path, body),
             Err(e) => {
                 return self.send_server_error(
                     ServerError::BadRequest {
-                        why: format!("error replacing params in path: {}", e),
+                        why: format!("error computing api request path or body: {}", e),
                     },
                     Some(StatusCode::BAD_REQUEST),
                 );
             }
         };
 
-        let http_method = endpoint.method.unwrap_or_default().to_string();
-        let mut headers = vec![
-            (ARCH_UPSTREAM_HOST_HEADER, endpoint.name.as_str()),
-            (":method", &http_method),
+        let http_method_str = http_method.to_string();
+        let mut headers: HashMap<_, _> = [
+            (ARCH_UPSTREAM_HOST_HEADER, endpoint_details.name.as_str()),
+            (":method", &http_method_str),
             (":path", &path),
-            (":authority", endpoint.name.as_str()),
+            (":authority", endpoint_details.name.as_str()),
             ("content-type", "application/json"),
             ("x-envoy-max-retries", "3"),
-        ];
+        ]
+        .into_iter()
+        .collect();
 
         if self.request_id.is_some() {
-            headers.push((REQUEST_ID_HEADER, self.request_id.as_ref().unwrap()));
+            headers.insert(REQUEST_ID_HEADER, self.request_id.as_ref().unwrap());
         }
 
         if self.traceparent.is_some() {
-            headers.push((TRACE_PARENT_HEADER, self.traceparent.as_ref().unwrap()));
+            headers.insert(TRACE_PARENT_HEADER, self.traceparent.as_ref().unwrap());
         }
 
         let call_args = CallArgs::new(
             ARCH_INTERNAL_CLUSTER_NAME,
             &path,
-            headers,
-            Some(tool_params_json_str.as_bytes()),
+            headers.into_iter().collect(),
+            body.as_deref().map(|s| s.as_bytes()),
             vec![],
             Duration::from_secs(5),
         );
 
         debug!(
-            "dispatching api call to developer endpoint: {}, path: {}",
-            endpoint.name, path
+            "dispatching api call to developer endpoint: {}, path: {}, method: {}",
+            endpoint_details.name, path, http_method_str
         );
-        trace!("request body: {}", tool_params_json_str);
 
-        callout_context.upstream_cluster = Some(endpoint.name.to_owned());
+        callout_context.upstream_cluster = Some(endpoint_details.name.to_owned());
         callout_context.upstream_cluster_path = Some(path.to_owned());
         callout_context.response_handler_type = ResponseHandlerType::FunctionCall;