refactor: add FieldMapper base class and migrate 41 simple mappers

src/celeste/parameters.py

@@ -2,7 +2,7 @@
 
 from abc import ABC, abstractmethod
 from enum import StrEnum
-from typing import Any, TypedDict
+from typing import Any, ClassVar, TypedDict
 
 from celeste.models import Model
 from celeste.types import TextContent
@@ -15,7 +15,7 @@ class Parameters(TypedDict, total=False):
 class ParameterMapper(ABC):
     """Base class for provider-specific parameter transformation."""
 
-    name: StrEnum
+    name: ClassVar[StrEnum]
     """Parameter name matching capability TypedDict key. Must be StrEnum for type safety."""
 
     @abstractmethod
@@ -48,4 +48,18 @@ def _validate_value(self, value: Any, model: Model) -> Any:  # noqa: ANN401
         return constraint(value)
 
 
-__all__ = ["ParameterMapper", "Parameters"]
+class FieldMapper(ParameterMapper):
+    """Maps a parameter directly to a flat request field after validation."""
+
+    field: ClassVar[str]
+
+    def map(self, request: dict[str, Any], value: Any, model: Model) -> dict[str, Any]:  # noqa: ANN401
+        """Transform parameter value into provider's request structure."""
+        validated_value = self._validate_value(value, model)
+        if validated_value is None:
+            return request
+        request[self.field] = validated_value
+        return request
+
+
+__all__ = ["FieldMapper", "ParameterMapper", "Parameters"]

src/celeste/protocols/chatcompletions/parameters.py

@@ -6,44 +6,20 @@
 from pydantic import BaseModel, TypeAdapter
 
 from celeste.models import Model
-from celeste.parameters import ParameterMapper
+from celeste.parameters import FieldMapper, ParameterMapper
 from celeste.types import TextContent
 
 
-class TemperatureMapper(ParameterMapper):
+class TemperatureMapper(FieldMapper):
     """Map temperature to Chat Completions temperature field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform temperature into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["temperature"] = validated_value
-        return request
+    field = "temperature"
 
 
-class MaxTokensMapper(ParameterMapper):
+class MaxTokensMapper(FieldMapper):
     """Map max_tokens to Chat Completions max_tokens field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform max_tokens into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["max_tokens"] = validated_value
-        return request
+    field = "max_tokens"
 
 
 class ResponseFormatMapper(ParameterMapper):

src/celeste/protocols/openresponses/parameters.py

@@ -6,45 +6,21 @@
 from pydantic import BaseModel, TypeAdapter
 
 from celeste.models import Model
-from celeste.parameters import ParameterMapper
+from celeste.parameters import FieldMapper, ParameterMapper
 from celeste.structured_outputs import StrictJsonSchemaGenerator
 from celeste.types import TextContent
 
 
-class TemperatureMapper(ParameterMapper):
+class TemperatureMapper(FieldMapper):
     """Map temperature to Responses temperature field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform temperature into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["temperature"] = validated_value
-        return request
+    field = "temperature"
 
 
-class MaxOutputTokensMapper(ParameterMapper):
+class MaxOutputTokensMapper(FieldMapper):
     """Map max_tokens to Responses max_output_tokens field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform max_tokens into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["max_output_tokens"] = validated_value
-        return request
+    field = "max_output_tokens"
 
 
 class TextFormatMapper(ParameterMapper):

src/celeste/providers/anthropic/messages/parameters.py

@@ -6,99 +6,39 @@
 from pydantic import BaseModel, TypeAdapter
 
 from celeste.models import Model
-from celeste.parameters import ParameterMapper
+from celeste.parameters import FieldMapper, ParameterMapper
 from celeste.structured_outputs import StrictJsonSchemaGenerator
 from celeste.types import TextContent
 
 
-class TemperatureMapper(ParameterMapper):
+class TemperatureMapper(FieldMapper):
     """Map temperature to Anthropic temperature field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform temperature into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["temperature"] = validated_value
-        return request
+    field = "temperature"
 
 
-class TopPMapper(ParameterMapper):
+class TopPMapper(FieldMapper):
     """Map top_p to Anthropic top_p field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform top_p into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["top_p"] = validated_value
-        return request
+    field = "top_p"
 
 
-class TopKMapper(ParameterMapper):
+class TopKMapper(FieldMapper):
     """Map top_k to Anthropic top_k field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform top_k into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
+    field = "top_k"
 
-        request["top_k"] = validated_value
-        return request
 
-
-class MaxTokensMapper(ParameterMapper):
+class MaxTokensMapper(FieldMapper):
     """Map max_tokens to Anthropic max_tokens field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform max_tokens into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["max_tokens"] = validated_value
-        return request
+    field = "max_tokens"
 
 
-class StopSequencesMapper(ParameterMapper):
+class StopSequencesMapper(FieldMapper):
     """Map stop_sequences to Anthropic stop_sequences field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform stop_sequences into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["stop_sequences"] = validated_value
-        return request
+    field = "stop_sequences"
 
 
 class ThinkingMapper(ParameterMapper):

src/celeste/providers/bfl/images/parameters.py

@@ -4,7 +4,7 @@
 
 from celeste.constraints import Int
 from celeste.models import Model
-from celeste.parameters import ParameterMapper
+from celeste.parameters import FieldMapper, ParameterMapper
 
 
 class WidthMapper(ParameterMapper):
@@ -41,112 +41,40 @@ def map(
         return request
 
 
-class PromptUpsamplingMapper(ParameterMapper):
+class PromptUpsamplingMapper(FieldMapper):
     """Map prompt_upsampling to BFL prompt_upsampling field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform prompt_upsampling into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["prompt_upsampling"] = validated_value
-        return request
+    field = "prompt_upsampling"
 
 
-class SeedMapper(ParameterMapper):
+class SeedMapper(FieldMapper):
     """Map seed to BFL seed field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform seed into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["seed"] = validated_value
-        return request
+    field = "seed"
 
 
-class SafetyToleranceMapper(ParameterMapper):
+class SafetyToleranceMapper(FieldMapper):
     """Map safety_tolerance to BFL safety_tolerance field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform safety_tolerance into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["safety_tolerance"] = validated_value
-        return request
+    field = "safety_tolerance"
 
 
-class OutputFormatMapper(ParameterMapper):
+class OutputFormatMapper(FieldMapper):
     """Map output_format to BFL output_format field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform output_format into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["output_format"] = validated_value
-        return request
+    field = "output_format"
 
 
-class StepsMapper(ParameterMapper):
+class StepsMapper(FieldMapper):
     """Map steps to BFL steps field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform steps into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["steps"] = validated_value
-        return request
+    field = "steps"
 
 
-class GuidanceMapper(ParameterMapper):
+class GuidanceMapper(FieldMapper):
     """Map guidance to BFL guidance field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform guidance into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["guidance"] = validated_value
-        return request
+    field = "guidance"
 
 
 __all__ = [