llama-stack 0.4.4__py3-none-any.whl → 0.5.0rc1__py3-none-any.whl

llama_stack/core/routers/eval_scoring.py

@@ -3,7 +3,6 @@
 #
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
-
 from typing import Any
 
 from llama_stack.log import get_logger
@@ -11,12 +10,23 @@ from llama_stack_api import (
     BenchmarkConfig,
     Eval,
     EvaluateResponse,
+    EvaluateRowsRequest,
     Job,
+    JobCancelRequest,
+    JobResultRequest,
+    JobStatusRequest,
     RoutingTable,
+    RunEvalRequest,
+    ScoreBatchRequest,
     ScoreBatchResponse,
+    ScoreRequest,
     ScoreResponse,
     Scoring,
-    ScoringFnParams,
+    resolve_evaluate_rows_request,
+    resolve_job_cancel_request,
+    resolve_job_result_request,
+    resolve_job_status_request,
+    resolve_run_eval_request,
 )
 
 logger = get_logger(name=__name__, category="core::routers")
@@ -40,21 +50,22 @@ class ScoringRouter(Scoring):
 
     async def score_batch(
         self,
-        dataset_id: str,
-        scoring_functions: dict[str, ScoringFnParams | None] = None,
-        save_results_dataset: bool = False,
+        request: ScoreBatchRequest,
     ) -> ScoreBatchResponse:
-        logger.debug(f"ScoringRouter.score_batch: {dataset_id}")
+        logger.debug(f"ScoringRouter.score_batch: {request.dataset_id}")
         res = {}
-        for fn_identifier in scoring_functions.keys():
+        for fn_identifier in request.scoring_functions.keys():
             provider = await self.routing_table.get_provider_impl(fn_identifier)
-            score_response = await provider.score_batch(
-                dataset_id=dataset_id,
-                scoring_functions={fn_identifier: scoring_functions[fn_identifier]},
+            # Create a request for this specific scoring function
+            single_fn_request = ScoreBatchRequest(
+                dataset_id=request.dataset_id,
+                scoring_functions={fn_identifier: request.scoring_functions[fn_identifier]},
+                save_results_dataset=request.save_results_dataset,
             )
+            score_response = await provider.score_batch(single_fn_request)
             res.update(score_response.results)
 
-        if save_results_dataset:
+        if request.save_results_dataset:
             raise NotImplementedError("Save results dataset not implemented yet")
 
         return ScoreBatchResponse(
@@ -63,18 +74,19 @@ class ScoringRouter(Scoring):
 
     async def score(
         self,
-        input_rows: list[dict[str, Any]],
-        scoring_functions: dict[str, ScoringFnParams | None] = None,
+        request: ScoreRequest,
     ) -> ScoreResponse:
-        logger.debug(f"ScoringRouter.score: {len(input_rows)} rows, {len(scoring_functions)} functions")
+        logger.debug(f"ScoringRouter.score: {len(request.input_rows)} rows, {len(request.scoring_functions)} functions")
         res = {}
         # look up and map each scoring function to its provider impl
-        for fn_identifier in scoring_functions.keys():
+        for fn_identifier in request.scoring_functions.keys():
             provider = await self.routing_table.get_provider_impl(fn_identifier)
-            score_response = await provider.score(
-                input_rows=input_rows,
-                scoring_functions={fn_identifier: scoring_functions[fn_identifier]},
+            # Create a request for this specific scoring function
+            single_fn_request = ScoreRequest(
+                input_rows=request.input_rows,
+                scoring_functions={fn_identifier: request.scoring_functions[fn_identifier]},
             )
+            score_response = await provider.score(single_fn_request)
             res.update(score_response.results)
 
         return ScoreResponse(results=res)
@@ -98,61 +110,139 @@ class EvalRouter(Eval):
 
     async def run_eval(
         self,
-        benchmark_id: str,
-        benchmark_config: BenchmarkConfig,
+        request: RunEvalRequest | None = None,
+        *,
+        benchmark_id: str | None = None,
+        benchmark_config: BenchmarkConfig | None = None,
     ) -> Job:
-        logger.debug(f"EvalRouter.run_eval: {benchmark_id}")
-        provider = await self.routing_table.get_provider_impl(benchmark_id)
-        return await provider.run_eval(
-            benchmark_id=benchmark_id,
-            benchmark_config=benchmark_config,
+        """Run an evaluation on a benchmark.
+
+        Supports both new-style (request object) and old-style (individual parameters).
+        Old-style usage is deprecated and will emit a DeprecationWarning.
+
+        Args:
+            request: The new-style request object (preferred)
+            benchmark_id: (Deprecated) The benchmark ID
+            benchmark_config: (Deprecated) The benchmark configuration
+
+        Returns:
+            Job object representing the evaluation job
+        """
+        resolved_request = resolve_run_eval_request(
+            request, benchmark_id=benchmark_id, benchmark_config=benchmark_config
         )
+        logger.debug(f"EvalRouter.run_eval: {resolved_request.benchmark_id}")
+        provider = await self.routing_table.get_provider_impl(resolved_request.benchmark_id)
+        return await provider.run_eval(resolved_request)
 
     async def evaluate_rows(
         self,
-        benchmark_id: str,
-        input_rows: list[dict[str, Any]],
-        scoring_functions: list[str],
-        benchmark_config: BenchmarkConfig,
+        request: EvaluateRowsRequest | None = None,
+        *,
+        benchmark_id: str | None = None,
+        input_rows: list[dict[str, Any]] | None = None,
+        scoring_functions: list[str] | None = None,
+        benchmark_config: BenchmarkConfig | None = None,
     ) -> EvaluateResponse:
-        logger.debug(f"EvalRouter.evaluate_rows: {benchmark_id}, {len(input_rows)} rows")
-        provider = await self.routing_table.get_provider_impl(benchmark_id)
-        return await provider.evaluate_rows(
+        """Evaluate a list of rows on a benchmark.
+
+        Supports both new-style (request object) and old-style (individual parameters).
+        Old-style usage is deprecated and will emit a DeprecationWarning.
+
+        Args:
+            request: The new-style request object (preferred)
+            benchmark_id: (Deprecated) The benchmark ID
+            input_rows: (Deprecated) The rows to evaluate
+            scoring_functions: (Deprecated) The scoring functions to use
+            benchmark_config: (Deprecated) The benchmark configuration
+
+        Returns:
+            EvaluateResponse object containing generations and scores
+        """
+        resolved_request = resolve_evaluate_rows_request(
+            request,
             benchmark_id=benchmark_id,
             input_rows=input_rows,
             scoring_functions=scoring_functions,
             benchmark_config=benchmark_config,
         )
+        logger.debug(
+            f"EvalRouter.evaluate_rows: {resolved_request.benchmark_id}, {len(resolved_request.input_rows)} rows"
+        )
+        provider = await self.routing_table.get_provider_impl(resolved_request.benchmark_id)
+        return await provider.evaluate_rows(resolved_request)
 
     async def job_status(
         self,
-        benchmark_id: str,
-        job_id: str,
+        request: JobStatusRequest | None = None,
+        *,
+        benchmark_id: str | None = None,
+        job_id: str | None = None,
     ) -> Job:
-        logger.debug(f"EvalRouter.job_status: {benchmark_id}, {job_id}")
-        provider = await self.routing_table.get_provider_impl(benchmark_id)
-        return await provider.job_status(benchmark_id, job_id)
+        """Get the status of a job.
+
+        Supports both new-style (request object) and old-style (individual parameters).
+        Old-style usage is deprecated and will emit a DeprecationWarning.
+
+        Args:
+            request: The new-style request object (preferred)
+            benchmark_id: (Deprecated) The benchmark ID
+            job_id: (Deprecated) The job ID
+
+        Returns:
+            Job object with the current status
+        """
+        resolved_request = resolve_job_status_request(request, benchmark_id=benchmark_id, job_id=job_id)
+        logger.debug(f"EvalRouter.job_status: {resolved_request.benchmark_id}, {resolved_request.job_id}")
+        provider = await self.routing_table.get_provider_impl(resolved_request.benchmark_id)
+        return await provider.job_status(resolved_request)
 
     async def job_cancel(
         self,
-        benchmark_id: str,
-        job_id: str,
+        request: JobCancelRequest | None = None,
+        *,
+        benchmark_id: str | None = None,
+        job_id: str | None = None,
     ) -> None:
-        logger.debug(f"EvalRouter.job_cancel: {benchmark_id}, {job_id}")
-        provider = await self.routing_table.get_provider_impl(benchmark_id)
-        await provider.job_cancel(
-            benchmark_id,
-            job_id,
-        )
+        """Cancel a job.
+
+        Supports both new-style (request object) and old-style (individual parameters).
+        Old-style usage is deprecated and will emit a DeprecationWarning.
+
+        Args:
+            request: The new-style request object (preferred)
+            benchmark_id: (Deprecated) The benchmark ID
+            job_id: (Deprecated) The job ID
+
+        Returns:
+            None
+        """
+        resolved_request = resolve_job_cancel_request(request, benchmark_id=benchmark_id, job_id=job_id)
+        logger.debug(f"EvalRouter.job_cancel: {resolved_request.benchmark_id}, {resolved_request.job_id}")
+        provider = await self.routing_table.get_provider_impl(resolved_request.benchmark_id)
+        await provider.job_cancel(resolved_request)
 
     async def job_result(
         self,
-        benchmark_id: str,
-        job_id: str,
+        request: JobResultRequest | None = None,
+        *,
+        benchmark_id: str | None = None,
+        job_id: str | None = None,
     ) -> EvaluateResponse:
-        logger.debug(f"EvalRouter.job_result: {benchmark_id}, {job_id}")
-        provider = await self.routing_table.get_provider_impl(benchmark_id)
-        return await provider.job_result(
-            benchmark_id,
-            job_id,
-        )
+        """Get the result of a job.
+
+        Supports both new-style (request object) and old-style (individual parameters).
+        Old-style usage is deprecated and will emit a DeprecationWarning.
+
+        Args:
+            request: The new-style request object (preferred)
+            benchmark_id: (Deprecated) The benchmark ID
+            job_id: (Deprecated) The job ID
+
+        Returns:
+            EvaluateResponse object with the job results
+        """
+        resolved_request = resolve_job_result_request(request, benchmark_id=benchmark_id, job_id=job_id)
+        logger.debug(f"EvalRouter.job_result: {resolved_request.benchmark_id}, {resolved_request.job_id}")
+        provider = await self.routing_table.get_provider_impl(resolved_request.benchmark_id)
+        return await provider.job_result(resolved_request)

llama_stack/core/routers/inference.py

@@ -20,9 +20,11 @@ from llama_stack.core.request_headers import get_authenticated_user
 from llama_stack.log import get_logger
 from llama_stack.providers.utils.inference.inference_store import InferenceStore
 from llama_stack_api import (
+    GetChatCompletionRequest,
     HealthResponse,
     HealthStatus,
     Inference,
+    ListChatCompletionsRequest,
     ListOpenAIChatCompletionResponse,
     ModelNotFoundError,
     ModelType,
@@ -45,7 +47,7 @@ from llama_stack_api import (
     OpenAIMessageParam,
     OpenAITokenLogProb,
     OpenAITopLogProb,
-    Order,
+    RegisterModelRequest,
     RerankResponse,
     RoutingTable,
 )
@@ -87,7 +89,14 @@ class InferenceRouter(Inference):
         logger.debug(
             f"InferenceRouter.register_model: {model_id=} {provider_model_id=} {provider_id=} {metadata=} {model_type=}",
         )
-        await self.routing_table.register_model(model_id, provider_model_id, provider_id, metadata, model_type)
+        request = RegisterModelRequest(
+            model_id=model_id,
+            provider_model_id=provider_model_id,
+            provider_id=provider_id,
+            metadata=metadata,
+            model_type=model_type,
+        )
+        await self.routing_table.register_model(request)
 
     async def _get_model_provider(self, model_id: str, expected_model_type: str) -> tuple[Inference, str]:
         model = await self.routing_table.get_object_by_identifier("model", model_id)
@@ -229,18 +238,20 @@ class InferenceRouter(Inference):
 
     async def list_chat_completions(
         self,
-        after: str | None = None,
-        limit: int | None = 20,
-        model: str | None = None,
-        order: Order | None = Order.desc,
+        request: ListChatCompletionsRequest,
     ) -> ListOpenAIChatCompletionResponse:
         if self.store:
-            return await self.store.list_chat_completions(after, limit, model, order)
+            return await self.store.list_chat_completions(
+                after=request.after,
+                limit=request.limit,
+                model=request.model,
+                order=request.order,
+            )
         raise NotImplementedError("List chat completions is not supported: inference store is not configured.")
 
-    async def get_chat_completion(self, completion_id: str) -> OpenAICompletionWithInputMessages:
+    async def get_chat_completion(self, request: GetChatCompletionRequest) -> OpenAICompletionWithInputMessages:
         if self.store:
-            return await self.store.get_chat_completion(completion_id)
+            return await self.store.get_chat_completion(request.completion_id)
         raise NotImplementedError("Get chat completion is not supported: inference store is not configured.")
 
     async def _nonstream_openai_chat_completion(

llama_stack/core/routers/safety.py

@@ -4,14 +4,22 @@
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
 
-from typing import Any
-
 from opentelemetry import trace
 
 from llama_stack.core.datatypes import SafetyConfig
 from llama_stack.log import get_logger
 from llama_stack.telemetry.helpers import safety_request_span_attributes, safety_span_name
-from llama_stack_api import ModerationObject, OpenAIMessageParam, RoutingTable, RunShieldResponse, Safety, Shield
+from llama_stack_api import (
+    ModerationObject,
+    RegisterShieldRequest,
+    RoutingTable,
+    RunModerationRequest,
+    RunShieldRequest,
+    RunShieldResponse,
+    Safety,
+    Shield,
+    UnregisterShieldRequest,
+)
 
 logger = get_logger(name=__name__, category="core::routers")
 tracer = trace.get_tracer(__name__)
@@ -35,54 +43,38 @@ class SafetyRouter(Safety):
         logger.debug("SafetyRouter.shutdown")
         pass
 
-    async def register_shield(
-        self,
-        shield_id: str,
-        provider_shield_id: str | None = None,
-        provider_id: str | None = None,
-        params: dict[str, Any] | None = None,
-    ) -> Shield:
-        logger.debug(f"SafetyRouter.register_shield: {shield_id}")
-        return await self.routing_table.register_shield(shield_id, provider_shield_id, provider_id, params)
+    async def register_shield(self, request: RegisterShieldRequest) -> Shield:
+        logger.debug(f"SafetyRouter.register_shield: {request.shield_id}")
+        return await self.routing_table.register_shield(request)
 
     async def unregister_shield(self, identifier: str) -> None:
         logger.debug(f"SafetyRouter.unregister_shield: {identifier}")
-        return await self.routing_table.unregister_shield(identifier)
-
-    async def run_shield(
-        self,
-        shield_id: str,
-        messages: list[OpenAIMessageParam],
-        params: dict[str, Any] = None,
-    ) -> RunShieldResponse:
-        with tracer.start_as_current_span(name=safety_span_name(shield_id)):
-            logger.debug(f"SafetyRouter.run_shield: {shield_id}")
-            provider = await self.routing_table.get_provider_impl(shield_id)
-            response = await provider.run_shield(
-                shield_id=shield_id,
-                messages=messages,
-                params=params,
-            )
-
-            safety_request_span_attributes(shield_id, messages, response)
+        return await self.routing_table.unregister_shield(UnregisterShieldRequest(identifier=identifier))
+
+    async def run_shield(self, request: RunShieldRequest) -> RunShieldResponse:
+        with tracer.start_as_current_span(name=safety_span_name(request.shield_id)):
+            logger.debug(f"SafetyRouter.run_shield: {request.shield_id}")
+            provider = await self.routing_table.get_provider_impl(request.shield_id)
+            response = await provider.run_shield(request)
+            safety_request_span_attributes(request.shield_id, request.messages, response)
         return response
 
-    async def run_moderation(self, input: str | list[str], model: str | None = None) -> ModerationObject:
+    async def run_moderation(self, request: RunModerationRequest) -> ModerationObject:
         list_shields_response = await self.routing_table.list_shields()
         shields = list_shields_response.data
 
         selected_shield: Shield | None = None
-        provider_model: str | None = model
+        provider_model: str | None = request.model
 
-        if model:
-            matches: list[Shield] = [s for s in shields if model == s.provider_resource_id]
+        if request.model:
+            matches: list[Shield] = [s for s in shields if request.model == s.provider_resource_id]
             if not matches:
                 raise ValueError(
-                    f"No shield associated with provider_resource id {model}: choose from {[s.provider_resource_id for s in shields]}"
+                    f"No shield associated with provider_resource id {request.model}: choose from {[s.provider_resource_id for s in shields]}"
                 )
             if len(matches) > 1:
                 raise ValueError(
-                    f"Multiple shields associated with provider_resource id {model}: matched shields {[s.identifier for s in matches]}"
+                    f"Multiple shields associated with provider_resource id {request.model}: matched shields {[s.identifier for s in matches]}"
                 )
             selected_shield = matches[0]
         else:
@@ -105,9 +97,5 @@ class SafetyRouter(Safety):
         logger.debug(f"SafetyRouter.run_moderation: {shield_id}")
         provider = await self.routing_table.get_provider_impl(shield_id)
 
-        response = await provider.run_moderation(
-            input=input,
-            model=provider_model,
-        )
-
-        return response
+        provider_request = RunModerationRequest(input=request.input, model=provider_model)
+        return await provider.run_moderation(provider_request)

llama_stack/core/routers/vector_io.py

@@ -39,6 +39,7 @@ from llama_stack_api import (
     VectorStoreFileObject,
     VectorStoreFilesListInBatchResponse,
     VectorStoreFileStatus,
+    VectorStoreListFilesResponse,
     VectorStoreListResponse,
     VectorStoreObject,
     VectorStoreSearchResponsePage,
@@ -148,11 +149,12 @@ class VectorIORouter(VectorIO):
         self,
         params: Annotated[OpenAICreateVectorStoreRequestWithExtraBody, Body(...)],
     ) -> VectorStoreObject:
-        # Extract llama-stack-specific parameters from extra_body
+        # Extract llama-stack-specific parameters from extra_body or metadata
         extra = params.model_extra or {}
-        embedding_model = extra.get("embedding_model")
-        embedding_dimension = extra.get("embedding_dimension")
-        provider_id = extra.get("provider_id")
+        metadata = params.metadata or {}
+        embedding_model = extra.get("embedding_model", metadata.get("embedding_model"))
+        embedding_dimension = extra.get("embedding_dimension", metadata.get("embedding_dimension"))
+        provider_id = extra.get("provider_id", metadata.get("provider_id"))
 
         # Use default embedding model if not specified
         if (
@@ -166,8 +168,14 @@ class VectorIORouter(VectorIO):
             embedding_model = f"{embedding_provider_id}/{model_id}"
 
         if embedding_model is not None and embedding_dimension is None:
-            embedding_dimension = await self._get_embedding_model_dimension(embedding_model)
-
+            if (
+                self.vector_stores_config
+                and self.vector_stores_config.default_embedding_model is not None
+                and self.vector_stores_config.default_embedding_model.embedding_dimensions
+            ):
+                embedding_dimension = self.vector_stores_config.default_embedding_model.embedding_dimensions
+            else:
+                embedding_dimension = await self._get_embedding_model_dimension(embedding_model)
         # Validate that embedding model exists and is of the correct type
         if embedding_model is not None:
             model = await self.routing_table.get_object_by_identifier("model", embedding_model)
@@ -376,7 +384,7 @@ class VectorIORouter(VectorIO):
         after: str | None = None,
         before: str | None = None,
         filter: VectorStoreFileStatus | None = None,
-    ) -> list[VectorStoreFileObject]:
+    ) -> VectorStoreListFilesResponse:
         logger.debug(f"VectorIORouter.openai_list_files_in_vector_store: {vector_store_id}")
         return await self.routing_table.openai_list_files_in_vector_store(
             vector_store_id=vector_store_id,

llama_stack/core/routing_tables/models.py

@@ -16,6 +16,7 @@ from llama_stack.core.request_headers import PROVIDER_DATA_VAR, NeedsRequestProv
 from llama_stack.core.utils.dynamic import instantiate_class_type
 from llama_stack.log import get_logger
 from llama_stack_api import (
+    GetModelRequest,
     ListModelsResponse,
     Model,
     ModelNotFoundError,
@@ -23,6 +24,8 @@ from llama_stack_api import (
     ModelType,
     OpenAIListModelsResponse,
     OpenAIModel,
+    RegisterModelRequest,
+    UnregisterModelRequest,
 )
 
 from .common import CommonRoutingTableImpl, lookup_model
@@ -171,7 +174,12 @@ class ModelsRoutingTable(CommonRoutingTableImpl, Models):
         ]
         return OpenAIListModelsResponse(data=openai_models)
 
-    async def get_model(self, model_id: str) -> Model:
+    async def get_model(self, request_or_model_id: GetModelRequest | str) -> Model:
+        # Support both the public Models API (GetModelRequest) and internal ModelStore interface (string)
+        if isinstance(request_or_model_id, GetModelRequest):
+            model_id = request_or_model_id.model_id
+        else:
+            model_id = request_or_model_id
         return await lookup_model(self, model_id)
 
     async def get_provider_impl(self, model_id: str) -> Any:
@@ -195,12 +203,28 @@ class ModelsRoutingTable(CommonRoutingTableImpl, Models):
 
     async def register_model(
         self,
-        model_id: str,
+        request: RegisterModelRequest | str | None = None,
+        *,
+        model_id: str | None = None,
         provider_model_id: str | None = None,
         provider_id: str | None = None,
         metadata: dict[str, Any] | None = None,
         model_type: ModelType | None = None,
     ) -> Model:
+        # Support both the public Models API (RegisterModelRequest) and legacy parameter-based interface
+        if isinstance(request, RegisterModelRequest):
+            model_id = request.model_id
+            provider_model_id = request.provider_model_id
+            provider_id = request.provider_id
+            metadata = request.metadata
+            model_type = request.model_type
+        elif isinstance(request, str):
+            # Legacy positional argument: register_model("model-id", ...)
+            model_id = request
+
+        if model_id is None:
+            raise ValueError("Either request or model_id must be provided")
+
         if provider_id is None:
             # If provider_id not specified, use the only provider if it supports this model
             if len(self.impls_by_provider_id) == 1:
@@ -229,7 +253,22 @@ class ModelsRoutingTable(CommonRoutingTableImpl, Models):
         registered_model = await self.register_object(model)
         return registered_model
 
-    async def unregister_model(self, model_id: str) -> None:
+    async def unregister_model(
+        self,
+        request: UnregisterModelRequest | str | None = None,
+        *,
+        model_id: str | None = None,
+    ) -> None:
+        # Support both the public Models API (UnregisterModelRequest) and legacy parameter-based interface
+        if isinstance(request, UnregisterModelRequest):
+            model_id = request.model_id
+        elif isinstance(request, str):
+            # Legacy positional argument: unregister_model("model-id")
+            model_id = request
+
+        if model_id is None:
+            raise ValueError("Either request or model_id must be provided")
+
         existing_model = await self.get_model(model_id)
         if existing_model is None:
             raise ModelNotFoundError(model_id)

llama_stack/core/routing_tables/scoring_functions.py

@@ -9,12 +9,14 @@ from llama_stack.core.datatypes import (
 )
 from llama_stack.log import get_logger
 from llama_stack_api import (
+    GetScoringFunctionRequest,
+    ListScoringFunctionsRequest,
     ListScoringFunctionsResponse,
-    ParamType,
+    RegisterScoringFunctionRequest,
     ResourceType,
     ScoringFn,
-    ScoringFnParams,
     ScoringFunctions,
+    UnregisterScoringFunctionRequest,
 )
 
 from .common import CommonRoutingTableImpl
@@ -23,26 +25,23 @@ logger = get_logger(name=__name__, category="core::routing_tables")
 
 
 class ScoringFunctionsRoutingTable(CommonRoutingTableImpl, ScoringFunctions):
-    async def list_scoring_functions(self) -> ListScoringFunctionsResponse:
+    async def list_scoring_functions(self, request: ListScoringFunctionsRequest) -> ListScoringFunctionsResponse:
         return ListScoringFunctionsResponse(data=await self.get_all_with_type(ResourceType.scoring_function.value))
 
-    async def get_scoring_function(self, scoring_fn_id: str) -> ScoringFn:
-        scoring_fn = await self.get_object_by_identifier("scoring_function", scoring_fn_id)
+    async def get_scoring_function(self, request: GetScoringFunctionRequest) -> ScoringFn:
+        scoring_fn = await self.get_object_by_identifier("scoring_function", request.scoring_fn_id)
         if scoring_fn is None:
-            raise ValueError(f"Scoring function '{scoring_fn_id}' not found")
+            raise ValueError(f"Scoring function '{request.scoring_fn_id}' not found")
         return scoring_fn
 
     async def register_scoring_function(
         self,
-        scoring_fn_id: str,
-        description: str,
-        return_type: ParamType,
-        provider_scoring_fn_id: str | None = None,
-        provider_id: str | None = None,
-        params: ScoringFnParams | None = None,
+        request: RegisterScoringFunctionRequest,
     ) -> None:
+        provider_scoring_fn_id = request.provider_scoring_fn_id
         if provider_scoring_fn_id is None:
-            provider_scoring_fn_id = scoring_fn_id
+            provider_scoring_fn_id = request.scoring_fn_id
+        provider_id = request.provider_id
         if provider_id is None:
             if len(self.impls_by_provider_id) == 1:
                 provider_id = list(self.impls_by_provider_id.keys())[0]
@@ -51,16 +50,17 @@ class ScoringFunctionsRoutingTable(CommonRoutingTableImpl, ScoringFunctions):
                     "No provider specified and multiple providers available. Please specify a provider_id."
                 )
         scoring_fn = ScoringFnWithOwner(
-            identifier=scoring_fn_id,
-            description=description,
-            return_type=return_type,
+            identifier=request.scoring_fn_id,
+            description=request.description,
+            return_type=request.return_type,
             provider_resource_id=provider_scoring_fn_id,
             provider_id=provider_id,
-            params=params,
+            params=request.params,
         )
         scoring_fn.provider_id = provider_id
         await self.register_object(scoring_fn)
 
-    async def unregister_scoring_function(self, scoring_fn_id: str) -> None:
-        existing_scoring_fn = await self.get_scoring_function(scoring_fn_id)
+    async def unregister_scoring_function(self, request: UnregisterScoringFunctionRequest) -> None:
+        get_request = GetScoringFunctionRequest(scoring_fn_id=request.scoring_fn_id)
+        existing_scoring_fn = await self.get_scoring_function(get_request)
         await self.unregister_object(existing_scoring_fn)