diff --git a/golem-worker-service-base/src/api/custom_http_request_api.rs b/golem-worker-service-base/src/api/custom_http_request_api.rs
index 8f6bd7d10..0513b41e9 100644
--- a/golem-worker-service-base/src/api/custom_http_request_api.rs
+++ b/golem-worker-service-base/src/api/custom_http_request_api.rs
@@ -12,8 +12,6 @@ use crate::worker_binding::golem_worker_binding::ResponseMapping;
 use crate::worker_binding::worker_binding_resolver::WorkerBindingResolver;
 use crate::worker_bridge::WorkerRequest;
 use crate::worker_bridge::workr_request_executor::WorkerRequestExecutor;
-use crate::worker_request::worker_request_to_response::WorkerRequestToResponse;
-use crate::worker_request::WorkerRequest;
 
 // Executes custom request with the help of worker_request_executor and definition_service
 // This is a common API projects can make use of, similar to healthcheck service
diff --git a/golem-worker-service-base/src/api/register_api_definition_api.rs b/golem-worker-service-base/src/api/register_api_definition_api.rs
index 5790d13a0..62abe2e07 100644
--- a/golem-worker-service-base/src/api/register_api_definition_api.rs
+++ b/golem-worker-service-base/src/api/register_api_definition_api.rs
@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 
 use golem_common::model::TemplateId;
 
-use crate::definition::api_definition::{ApiDefinitionId, Version};
+use crate::definition::api_definition::{ApiDefinitionId, ApiVersion};
 use crate::expression::expr::Expr;
 use crate::http::http_api_definition::MethodPattern;
 
@@ -18,7 +18,7 @@ use crate::http::http_api_definition::MethodPattern;
 #[oai(rename_all = "camelCase")]
 pub struct HttpApiDefinition {
     pub id: ApiDefinitionId,
-    pub version: Version,
+    pub version: ApiVersion,
     pub routes: Vec<Route>,
 }
 
diff --git a/golem-worker-service-base/src/definition/api_definition.rs b/golem-worker-service-base/src/definition/api_definition.rs
index 92bee76f8..14a1df523 100644
--- a/golem-worker-service-base/src/definition/api_definition.rs
+++ b/golem-worker-service-base/src/definition/api_definition.rs
@@ -20,9 +20,9 @@ impl Display for ApiDefinitionId {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize, Encode, Decode, NewType)]
-pub struct Version(pub String);
+pub struct ApiVersion(pub String);
 
-impl Display for Version {
+impl Display for ApiVersion {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.0)
     }
@@ -34,7 +34,7 @@ pub(crate) trait HasApiDefinitionId {
 }
 
 pub(crate) trait HasVersion {
-    fn get_version(&self) -> Version;
+    fn get_version(&self) -> ApiVersion;
 }
 
 pub(crate) trait HasGolemWorkerBindings {
diff --git a/golem-worker-service-base/src/http/http_api_definition.rs b/golem-worker-service-base/src/http/http_api_definition.rs
index e59bc52d3..db3599c32 100644
--- a/golem-worker-service-base/src/http/http_api_definition.rs
+++ b/golem-worker-service-base/src/http/http_api_definition.rs
@@ -9,7 +9,7 @@ use poem_openapi::Enum;
 use serde::{Deserialize, Serialize, Serializer};
 use serde_json::Value;
 
-use crate::definition::api_definition::{ApiDefinitionId, HasApiDefinitionId, HasGolemWorkerBindings, HasVersion, Version};
+use crate::definition::api_definition::{ApiDefinitionId, HasApiDefinitionId, HasGolemWorkerBindings, HasVersion, ApiVersion};
 use crate::parser::{GolemParser, ParseError};
 use crate::parser::path_pattern_parser::PathPatternParser;
 use crate::worker_binding::golem_worker_binding::GolemWorkerBinding;
@@ -18,7 +18,7 @@ use crate::worker_binding::golem_worker_binding::GolemWorkerBinding;
 #[serde(rename_all = "camelCase")]
 pub struct HttpApiDefinition {
     pub id: ApiDefinitionId,
-    pub version: Version,
+    pub version: ApiVersion,
     pub routes: Vec<Route>,
 }
 
@@ -38,7 +38,7 @@ impl HasApiDefinitionId for HttpApiDefinition {
 }
 
 impl HasVersion for HttpApiDefinition {
-    fn get_version(&self) -> Version {
+    fn get_version(&self) -> ApiVersion {
         self.version.clone()
     }
 }
diff --git a/golem-worker-service-base/src/http/oas_worker_bridge.rs b/golem-worker-service-base/src/http/oas_worker_bridge.rs
index 3dc00abe2..cf478b5ce 100644
--- a/golem-worker-service-base/src/http/oas_worker_bridge.rs
+++ b/golem-worker-service-base/src/http/oas_worker_bridge.rs
@@ -1,22 +1,11 @@
-use std::collections::HashMap;
-
-use openapiv3::{OpenAPI, PathItem, Paths, ReferenceOr};
+use openapiv3::{OpenAPI};
 use serde_json;
-use serde_json::Value;
-use uuid::Uuid;
-
-use golem_common::model::TemplateId;
 
-use crate::definition::api_definition::{ApiDefinitionId, Version};
-use crate::expression::expr::Expr;
-use crate::http::http_api_definition::{HttpApiDefinition, MethodPattern, PathPattern, Route};
-use crate::worker_binding::golem_worker_binding::{GolemWorkerBinding, ResponseMapping};
+use crate::definition::api_definition::{ApiDefinitionId, ApiVersion};
+use crate::http::http_api_definition::{HttpApiDefinition};
+use internal::*;
 
-pub const GOLEM_API_DEFINITION_ID_EXTENSION: &str = "x-golem-api-definition-id";
-pub const GOLEM_API_DEFINITION_VERSION: &str = "x-golem-api-definition-version";
-pub const GOLEM_WORKER_BRIDGE_EXTENSION: &str = "x-golem-worker-bridge";
-
-pub fn get_api_definition(open_api: &str) -> Result<HttpApiDefinition, String> {
+pub fn get_api_definition_from_oas(open_api: &str) -> Result<HttpApiDefinition, String> {
     let openapi: OpenAPI = serde_json::from_str(open_api).map_err(|e| e.to_string())?;
 
     let api_definition_id = ApiDefinitionId(get_root_extension(
@@ -25,7 +14,7 @@ pub fn get_api_definition(open_api: &str) -> Result<HttpApiDefinition, String> {
     )?);
 
     let api_definition_version =
-        Version(get_root_extension(&openapi, GOLEM_API_DEFINITION_VERSION)?);
+        ApiVersion(get_root_extension(&openapi, GOLEM_API_DEFINITION_VERSION)?);
 
     let routes = get_routes(openapi.paths)?;
 
@@ -36,158 +25,175 @@ pub fn get_api_definition(open_api: &str) -> Result<HttpApiDefinition, String> {
     })
 }
 
-fn get_root_extension(open_api: &OpenAPI, key_name: &str) -> Result<String, String> {
-    open_api
-        .extensions
-        .iter()
-        .find(|(key, _)| key.to_lowercase() == key_name)
-        .map(|(_, value)| value)
-        .ok_or(format!("{} not found in the open API spec", key_name))?
-        .as_str()
-        .ok_or(format!("Invalid value for {}", key_name))
-        .map(|x| x.to_string())
-}
+mod internal {
+    use std::collections::HashMap;
+    use openapiv3::{OpenAPI, PathItem, Paths, ReferenceOr};
+    use serde_json::Value;
+    use uuid::Uuid;
+    use golem_common::model::TemplateId;
+    use crate::expression::expr::Expr;
+    use crate::http::http_api_definition::{MethodPattern, PathPattern, Route};
+    use crate::worker_binding::golem_worker_binding::{GolemWorkerBinding, ResponseMapping};
+
+    pub(crate) const GOLEM_API_DEFINITION_ID_EXTENSION: &str = "x-golem-api-definition-id";
+    pub(crate) const GOLEM_API_DEFINITION_VERSION: &str = "x-golem-api-definition-version";
+    pub(crate) const GOLEM_WORKER_BRIDGE_EXTENSION: &str = "x-golem-worker-bridge";
+
+    pub(crate) fn get_root_extension(open_api: &OpenAPI, key_name: &str) -> Result<String, String> {
+        open_api
+            .extensions
+            .iter()
+            .find(|(key, _)| key.to_lowercase() == key_name)
+            .map(|(_, value)| value)
+            .ok_or(format!("{} not found in the open API spec", key_name))?
+            .as_str()
+            .ok_or(format!("Invalid value for {}", key_name))
+            .map(|x| x.to_string())
+    }
 
-fn get_routes(paths: Paths) -> Result<Vec<Route>, String> {
-    let mut routes: Vec<Route> = vec![];
+    pub(crate) fn get_routes(paths: Paths) -> Result<Vec<Route>, String> {
+        let mut routes: Vec<Route> = vec![];
 
-    for (path, path_item) in paths.iter() {
-        match path_item {
-            ReferenceOr::Item(item) => {
-                let path_pattern = get_path_pattern(path)?;
+        for (path, path_item) in paths.iter() {
+            match path_item {
+                ReferenceOr::Item(item) => {
+                    let path_pattern = get_path_pattern(path)?;
 
-                for (str, _) in item.iter() {
-                    let route = get_route_from_path_item(str, item, &path_pattern)?;
-                    routes.push(route);
+                    for (str, _) in item.iter() {
+                        let route = get_route_from_path_item(str, item, &path_pattern)?;
+                        routes.push(route);
+                    }
                 }
-            }
-            ReferenceOr::Reference { reference: _ } => {
-                return Err(
-                    "Reference not supported yet when extracting worker bridge extension info"
-                        .to_string(),
-                )
-            }
-        };
+                ReferenceOr::Reference { reference: _ } => {
+                    return Err(
+                        "Reference not supported yet when extracting worker bridge extension info"
+                            .to_string(),
+                    )
+                }
+            };
+        }
+
+        Ok(routes)
     }
 
-    Ok(routes)
-}
+    pub(crate) fn get_route_from_path_item(
+        method: &str,
+        path_item: &PathItem,
+        path_pattern: &PathPattern,
+    ) -> Result<Route, String> {
+        let method_res = match method {
+            "get" => Ok(MethodPattern::Get),
+            "post" => Ok(MethodPattern::Post),
+            "put" => Ok(MethodPattern::Put),
+            "delete" => Ok(MethodPattern::Delete),
+            "options" => Ok(MethodPattern::Options),
+            "head" => Ok(MethodPattern::Head),
+            "patch" => Ok(MethodPattern::Patch),
+            "trace" => Ok(MethodPattern::Trace),
+            _ => Err("Other methods not supported".to_string()),
+        };
 
-fn get_route_from_path_item(
-    method: &str,
-    path_item: &PathItem,
-    path_pattern: &PathPattern,
-) -> Result<Route, String> {
-    let method_res = match method {
-        "get" => Ok(MethodPattern::Get),
-        "post" => Ok(MethodPattern::Post),
-        "put" => Ok(MethodPattern::Put),
-        "delete" => Ok(MethodPattern::Delete),
-        "options" => Ok(MethodPattern::Options),
-        "head" => Ok(MethodPattern::Head),
-        "patch" => Ok(MethodPattern::Patch),
-        "trace" => Ok(MethodPattern::Trace),
-        _ => Err("Other methods not supported".to_string()),
-    };
-
-    let method = method_res?;
-
-    let worker_bridge_info = path_item
-        .extensions
-        .get(GOLEM_WORKER_BRIDGE_EXTENSION)
-        .ok_or(format!(
-            "No {} extension found",
-            GOLEM_WORKER_BRIDGE_EXTENSION
-        ))?;
-
-    let binding = GolemWorkerBinding {
-        worker_id: get_worker_id_expr(worker_bridge_info)?,
-        function_name: get_function_name(worker_bridge_info)?,
-        function_params: get_function_params_expr(worker_bridge_info)?,
-        template: get_template_id(worker_bridge_info)?,
-        response: get_response_mapping(worker_bridge_info)?,
-    };
-
-    Ok(Route {
-        path: path_pattern.clone(),
-        method,
-        binding,
-    })
-}
+        let method = method_res?;
+
+        let worker_bridge_info = path_item
+            .extensions
+            .get(GOLEM_WORKER_BRIDGE_EXTENSION)
+            .ok_or(format!(
+                "No {} extension found",
+                GOLEM_WORKER_BRIDGE_EXTENSION
+            ))?;
+
+        let binding = GolemWorkerBinding {
+            worker_id: get_worker_id_expr(worker_bridge_info)?,
+            function_name: get_function_name(worker_bridge_info)?,
+            function_params: get_function_params_expr(worker_bridge_info)?,
+            template: get_template_id(worker_bridge_info)?,
+            response: get_response_mapping(worker_bridge_info)?,
+        };
 
-fn get_template_id(worker_bridge_info: &Value) -> Result<TemplateId, String> {
-    let template_id = worker_bridge_info
-        .get("template-id")
-        .ok_or("No template-id found")?
-        .as_str()
-        .ok_or("template-id is not a string")?;
-    Ok(TemplateId(
-        Uuid::parse_str(template_id).map_err(|err| err.to_string())?,
-    ))
-}
+        Ok(Route {
+            path: path_pattern.clone(),
+            method,
+            binding,
+        })
+    }
 
-fn get_response_mapping(worker_bridge_info: &Value) -> Result<Option<ResponseMapping>, String> {
-    let response = worker_bridge_info.get("response");
-    match response {
-        Some(response) => Ok(Some(ResponseMapping {
-            status: Expr::from_json_value(response.get("status").ok_or("No status found")?)
-                .map_err(|err| err.to_string())?,
-            headers: {
-                let mut header_map = HashMap::new();
-
-                let header_iter = response
-                    .get("headers")
-                    .ok_or("No headers found")?
-                    .as_object()
-                    .ok_or("headers is not an object")?
-                    .iter();
-
-                for (header_name, value) in header_iter {
-                    let value_str = value.as_str().ok_or("Header value is not a string")?;
-                    header_map.insert(
-                        header_name.clone(),
-                        Expr::from_primitive_string(value_str).map_err(|err| err.to_string())?,
-                    );
-                }
+    pub(crate) fn get_template_id(worker_bridge_info: &Value) -> Result<TemplateId, String> {
+        let template_id = worker_bridge_info
+            .get("template-id")
+            .ok_or("No template-id found")?
+            .as_str()
+            .ok_or("template-id is not a string")?;
+        Ok(TemplateId(
+            Uuid::parse_str(template_id).map_err(|err| err.to_string())?,
+        ))
+    }
 
-                header_map
-            },
-            body: Expr::from_json_value(response.get("body").ok_or("No body found")?)
-                .map_err(|err| err.to_string())?,
-        })),
-        None => Ok(None),
+    pub(crate) fn get_response_mapping(worker_bridge_info: &Value) -> Result<Option<ResponseMapping>, String> {
+        let response = worker_bridge_info.get("response");
+        match response {
+            Some(response) => Ok(Some(ResponseMapping {
+                status: Expr::from_json_value(response.get("status").ok_or("No status found")?)
+                    .map_err(|err| err.to_string())?,
+                headers: {
+                    let mut header_map = HashMap::new();
+
+                    let header_iter = response
+                        .get("headers")
+                        .ok_or("No headers found")?
+                        .as_object()
+                        .ok_or("headers is not an object")?
+                        .iter();
+
+                    for (header_name, value) in header_iter {
+                        let value_str = value.as_str().ok_or("Header value is not a string")?;
+                        header_map.insert(
+                            header_name.clone(),
+                            Expr::from_primitive_string(value_str).map_err(|err| err.to_string())?,
+                        );
+                    }
+
+                    header_map
+                },
+                body: Expr::from_json_value(response.get("body").ok_or("No body found")?)
+                    .map_err(|err| err.to_string())?,
+            })),
+            None => Ok(None),
+        }
     }
-}
 
-fn get_function_params_expr(worker_bridge_info: &Value) -> Result<Vec<Expr>, String> {
-    let function_params = worker_bridge_info
-        .get("function-params")
-        .ok_or("No function-params found")?
-        .as_array()
-        .ok_or("function-params is not an array")?;
-    let mut exprs = vec![];
-    for param in function_params {
-        exprs.push(Expr::from_json_value(param).map_err(|err| err.to_string())?);
+    pub(crate) fn get_function_params_expr(worker_bridge_info: &Value) -> Result<Vec<Expr>, String> {
+        let function_params = worker_bridge_info
+            .get("function-params")
+            .ok_or("No function-params found")?
+            .as_array()
+            .ok_or("function-params is not an array")?;
+        let mut exprs = vec![];
+        for param in function_params {
+            exprs.push(Expr::from_json_value(param).map_err(|err| err.to_string())?);
+        }
+        Ok(exprs)
     }
-    Ok(exprs)
-}
 
-fn get_function_name(worker_bridge_info: &Value) -> Result<String, String> {
-    let function_name = worker_bridge_info
-        .get("function-name")
-        .ok_or("No function-name found")?
-        .as_str()
-        .ok_or("function-name is not a string")?;
-    Ok(function_name.to_string())
-}
+    pub(crate) fn get_function_name(worker_bridge_info: &Value) -> Result<String, String> {
+        let function_name = worker_bridge_info
+            .get("function-name")
+            .ok_or("No function-name found")?
+            .as_str()
+            .ok_or("function-name is not a string")?;
+        Ok(function_name.to_string())
+    }
 
-fn get_worker_id_expr(worker_bridge_info: &Value) -> Result<Expr, String> {
-    let worker_id = worker_bridge_info
-        .get("worker-id")
-        .ok_or("No worker-id found")?;
-    Expr::from_json_value(worker_id).map_err(|err| err.to_string())
-}
+    pub(crate) fn get_worker_id_expr(worker_bridge_info: &Value) -> Result<Expr, String> {
+        let worker_id = worker_bridge_info
+            .get("worker-id")
+            .ok_or("No worker-id found")?;
+        Expr::from_json_value(worker_id).map_err(|err| err.to_string())
+    }
+
+    pub(crate) fn get_path_pattern(path: &str) -> Result<PathPattern, String> {
+        PathPattern::from(path).map_err(|err| err.to_string())
+    }
 
-fn get_path_pattern(path: &str) -> Result<PathPattern, String> {
-    PathPattern::from(path).map_err(|err| err.to_string())
 }
+
diff --git a/golem-worker-service-base/src/lib.rs b/golem-worker-service-base/src/lib.rs
index 996960cde..83c06d96a 100644
--- a/golem-worker-service-base/src/lib.rs
+++ b/golem-worker-service-base/src/lib.rs
@@ -7,9 +7,11 @@ pub mod auth;
 pub mod worker_bridge;
 pub mod metrics;
 pub mod app_config;
+
+pub mod http;
+
 mod definition;
 mod expression;
-mod http;
 mod merge;
 mod parser;
 mod tokeniser;
@@ -17,6 +19,8 @@ mod worker_binding;
 mod evaluator;
 mod primitive;
 
+pub use crate::http::oas_worker_bridge::get_api_definition_from_oas;
+
 pub trait UriBackConversion {
     fn as_http_02(&self) -> http_02::Uri;
 }
diff --git a/golem-worker-service-base/src/repo/api_definition_repo.rs b/golem-worker-service-base/src/repo/api_definition_repo.rs
index efb16e401..758595385 100644
--- a/golem-worker-service-base/src/repo/api_definition_repo.rs
+++ b/golem-worker-service-base/src/repo/api_definition_repo.rs
@@ -389,7 +389,7 @@ mod tests {
 
     use golem_common::config::RedisConfig;
 
-    use crate::definition::api_definition::{ApiDefinitionId, Version};
+    use crate::definition::api_definition::{ApiDefinitionId, ApiVersion};
     use crate::http::http_api_definition::HttpApiDefinition;
 
     use super::*;
@@ -439,7 +439,7 @@ mod tests {
         let registry = InMemoryRegistry::default();
 
         let id = ApiDefinitionId("api1".to_string());
-        let version = Version("0.0.1".to_string());
+        let version = ApiVersion("0.0.1".to_string());
         let namespace = CommonNamespace::new("default");
 
         let api_id1 = ApiDefinitionKey {
@@ -455,7 +455,7 @@ mod tests {
         );
 
         let id2 = ApiDefinitionId("api2".to_string());
-        let version = Version("0.0.1".to_string());
+        let version = ApiVersion("0.0.1".to_string());
         let namespace = CommonNamespace::new("default");
 
         let api_id2 = ApiDefinitionKey {
@@ -523,7 +523,7 @@ mod tests {
         let api_id1 = ApiDefinitionKey {
             namespace: namespace.clone(),
             id: api_id.clone(),
-            version: Version("0.0.1".to_string()),
+            version: ApiVersion("0.0.1".to_string()),
         };
 
         let api_definition1 = get_simple_api_definition_example(
@@ -563,7 +563,7 @@ mod tests {
         let api_id2 = ApiDefinitionKey {
             namespace: namespace.clone(),
             id: api_id.clone(),
-            version: Version("0.0.2".to_string()),
+            version: ApiVersion("0.0.2".to_string()),
         };
 
         let api_definition2 = get_simple_api_definition_example(
@@ -589,7 +589,7 @@ mod tests {
         let api_id3 = ApiDefinitionKey {
             namespace: namespace.clone(),
             id: api_id2.clone(),
-            version: Version("0.0.1".to_string()),
+            version: ApiVersion("0.0.1".to_string()),
         };
 
         let api_definition3 = get_simple_api_definition_example(
@@ -647,7 +647,7 @@ mod tests {
         let api_id5 = ApiDefinitionKey {
             namespace: namespace2.clone(),
             id: api_id4.clone(),
-            version: Version("0.0.1".to_string()),
+            version: ApiVersion("0.0.1".to_string()),
         };
 
         let api_definition4 = get_simple_api_definition_example(
diff --git a/golem-worker-service-base/src/service/api_definition.rs b/golem-worker-service-base/src/service/api_definition.rs
index 675a0029d..24abbb148 100644
--- a/golem-worker-service-base/src/service/api_definition.rs
+++ b/golem-worker-service-base/src/service/api_definition.rs
@@ -9,7 +9,7 @@ use golem_common::model::TemplateId;
 use golem_service_base::model::Template;
 
 use crate::api::common::RouteValidationError;
-use crate::definition::api_definition::{ApiDefinitionId, HasApiDefinitionId, HasGolemWorkerBindings, HasVersion, Version};
+use crate::definition::api_definition::{ApiDefinitionId, HasApiDefinitionId, HasGolemWorkerBindings, HasVersion, ApiVersion};
 use crate::repo::api_definition_repo::{ApiDefinitionRepo, ApiRegistrationRepoError};
 
 use super::api_definition_validator::{ApiDefinitionValidatorService, ValidationErrors};
@@ -32,7 +32,7 @@ pub trait ApiDefinitionService<AuthCtx, Namespace, ApiDefinition, ValidationErro
     async fn get(
         &self,
         api_definition_id: &ApiDefinitionId,
-        version: &Version,
+        version: &ApiVersion,
         namespace: Namespace,
         auth_ctx: &AuthCtx,
     ) -> ApiResult<Option<ApiDefinition>, ValidationError>;
@@ -40,7 +40,7 @@ pub trait ApiDefinitionService<AuthCtx, Namespace, ApiDefinition, ValidationErro
     async fn delete(
         &self,
         api_definition_id: &ApiDefinitionId,
-        version: &Version,
+        version: &ApiVersion,
         namespace: Namespace,
         auth_ctx: &AuthCtx,
     ) -> ApiResult<Option<ApiDefinitionId>, ValidationError>;
@@ -99,7 +99,7 @@ impl<
 pub struct ApiDefinitionKey<Namespace> {
     pub namespace: Namespace,
     pub id: ApiDefinitionId,
-    pub version: Version,
+    pub version: ApiVersion,
 }
 
 impl<Namespace: Display> ApiDefinitionKey<Namespace> {
@@ -220,7 +220,7 @@ where
     async fn get(
         &self,
         api_definition_id: &ApiDefinitionId,
-        version: &Version,
+        version: &ApiVersion,
         namespace: Namespace,
         _auth_ctx: &AuthCtx,
     ) -> ApiResult<Option<ApiDefinition>, ValidationError> {
@@ -238,7 +238,7 @@ where
     async fn delete(
         &self,
         api_definition_id: &ApiDefinitionId,
-        version: &Version,
+        version: &ApiVersion,
         namespace: Namespace,
         _auth_ctx: &AuthCtx,
     ) -> ApiResult<Option<ApiDefinitionId>, ValidationError> {
@@ -300,7 +300,7 @@ where
     async fn get(
         &self,
         _api_definition_id: &ApiDefinitionId,
-        _version: &Version,
+        _version: &ApiVersion,
         _namespace: Namespace,
         _auth_ctx: &AuthCtx,
     ) -> ApiResult<Option<ApiDefinition>, ValidationError> {
@@ -310,7 +310,7 @@ where
     async fn delete(
         &self,
         _api_definition_id: &ApiDefinitionId,
-        _version: &Version,
+        _version: &ApiVersion,
         _namespace: Namespace,
         _auth_ctx: &AuthCtx,
     ) -> ApiResult<Option<ApiDefinitionId>, ValidationError> {
diff --git a/golem-worker-service/src/api/register_api_definition_api.rs b/golem-worker-service/src/api/register_api_definition_api.rs
index e44b823d5..5c7fb291a 100644
--- a/golem-worker-service/src/api/register_api_definition_api.rs
+++ b/golem-worker-service/src/api/register_api_definition_api.rs
@@ -7,19 +7,19 @@ use poem_openapi::*;
 use tracing::{error, info};
 
 use golem_service_base::api_tags::ApiTags;
-use golem_worker_service_base::api::common::ApiEndpointError;
+use golem_worker_service_base::api::common::{ApiEndpointError, RouteValidationError};
 use golem_worker_service_base::api::register_api_definition_api::HttpApiDefinition;
-use golem_worker_service_base::http_api_definition;
-use golem_worker_service_base::http_api_definition::{ApiDefinitionId, Version};
+use golem_worker_service_base::HttpApiDefinition as CoreHttpApiDefinition;
+use golem_worker_service_base::definition::api_definition::{ApiDefinitionId, ApiVersion};
 use golem_worker_service_base::auth::{CommonNamespace, EmptyAuthCtx};
-use golem_worker_service_base::oas_worker_bridge::*;
+use golem_worker_service_base::get_api_definition_from_oas;
 use golem_worker_service_base::service::api_definition::ApiDefinitionService;
 
 pub struct RegisterApiDefinitionApi {
     pub definition_service: DefinitionService,
 }
 
-type DefinitionService = Arc<dyn ApiDefinitionService<EmptyAuthCtx, CommonNamespace> + Sync + Send>;
+type DefinitionService = Arc<dyn ApiDefinitionService<EmptyAuthCtx, CommonNamespace, HttpApiDefinition, RouteValidationError> + Sync + Send>;
 
 #[OpenApi(prefix_path = "/v1/api/definitions", tag = ApiTags::ApiDefinition)]
 impl RegisterApiDefinitionApi {
@@ -32,7 +32,7 @@ impl RegisterApiDefinitionApi {
         &self,
         payload: String,
     ) -> Result<Json<HttpApiDefinition>, ApiEndpointError> {
-        let definition = get_api_definition(payload.as_str()).map_err(|e| {
+        let definition = get_api_definition_from_oas(payload.as_str()).map_err(|e| {
             error!("Invalid Spec {}", e);
             ApiEndpointError::bad_request(e)
         })?;
@@ -52,7 +52,7 @@ impl RegisterApiDefinitionApi {
     ) -> Result<Json<HttpApiDefinition>, ApiEndpointError> {
         info!("Save API definition - id: {}", &payload.id);
 
-        let definition: http_api_definition::HttpApiDefinition = payload
+        let definition: CoreHttpApiDefinition = payload
             .0
             .try_into()
             .map_err(ApiEndpointError::bad_request)?;
@@ -69,7 +69,7 @@ impl RegisterApiDefinitionApi {
     async fn get(
         &self,
         #[oai(name = "api-definition-id")] api_definition_id_query: Query<ApiDefinitionId>,
-        #[oai(name = "version")] api_definition_id_version: Query<Version>,
+        #[oai(name = "version")] api_definition_id_version: Query<ApiVersion>,
     ) -> Result<Json<Vec<HttpApiDefinition>>, ApiEndpointError> {
         let api_definition_id = api_definition_id_query.0;
 
@@ -105,7 +105,7 @@ impl RegisterApiDefinitionApi {
     async fn delete(
         &self,
         #[oai(name = "api-definition-id")] api_definition_id_query: Query<ApiDefinitionId>,
-        #[oai(name = "version")] api_definition_version_query: Query<Version>,
+        #[oai(name = "version")] api_definition_version_query: Query<ApiVersion>,
     ) -> Result<Json<String>, ApiEndpointError> {
         let api_definition_id = api_definition_id_query.0;
         let api_definition_version = api_definition_version_query.0;
@@ -196,7 +196,7 @@ mod test {
 
         let definition = http_api_definition::HttpApiDefinition {
             id: ApiDefinitionId("test".to_string()),
-            version: Version("1.0".to_string()),
+            version: ApiVersion("1.0".to_string()),
             routes: vec![],
         };
 
@@ -224,7 +224,7 @@ mod test {
 
         let definition = http_api_definition::HttpApiDefinition {
             id: ApiDefinitionId("test".to_string()),
-            version: Version("1.0".to_string()),
+            version: ApiVersion("1.0".to_string()),
             routes: vec![],
         };
         let response = client
@@ -236,7 +236,7 @@ mod test {
 
         let definition = http_api_definition::HttpApiDefinition {
             id: ApiDefinitionId("test".to_string()),
-            version: Version("2.0".to_string()),
+            version: ApiVersion("2.0".to_string()),
             routes: vec![],
         };
         let response = client