diff --git a/src/celeste/parameters.py b/src/celeste/parameters.py
index 4956996f..3be12812 100644
--- a/src/celeste/parameters.py
+++ b/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"]
diff --git a/src/celeste/protocols/chatcompletions/parameters.py b/src/celeste/protocols/chatcompletions/parameters.py
index c8fc8d4b..dfe4607e 100644
--- a/src/celeste/protocols/chatcompletions/parameters.py
+++ b/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):
diff --git a/src/celeste/protocols/openresponses/parameters.py b/src/celeste/protocols/openresponses/parameters.py
index 4a682570..635b27b6 100644
--- a/src/celeste/protocols/openresponses/parameters.py
+++ b/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):
diff --git a/src/celeste/providers/anthropic/messages/parameters.py b/src/celeste/providers/anthropic/messages/parameters.py
index 1dfd9d95..2b63bdaf 100644
--- a/src/celeste/providers/anthropic/messages/parameters.py
+++ b/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):
diff --git a/src/celeste/providers/bfl/images/parameters.py b/src/celeste/providers/bfl/images/parameters.py
index 3eacc702..39f92de1 100644
--- a/src/celeste/providers/bfl/images/parameters.py
+++ b/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__ = [
diff --git a/src/celeste/providers/byteplus/images/parameters.py b/src/celeste/providers/byteplus/images/parameters.py
index 866c84e5..b2bbbe02 100644
--- a/src/celeste/providers/byteplus/images/parameters.py
+++ b/src/celeste/providers/byteplus/images/parameters.py
@@ -1,45 +1,18 @@
 """BytePlus Images API parameter mappers."""
 
-from typing import Any
+from celeste.parameters import FieldMapper
 
-from celeste.models import Model
-from celeste.parameters import ParameterMapper
 
-
-class SizeMapper(ParameterMapper):
+class SizeMapper(FieldMapper):
     """Map size to BytePlus size field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform size into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["size"] = validated_value
-        return request
+    field = "size"
 
 
-class WatermarkMapper(ParameterMapper):
+class WatermarkMapper(FieldMapper):
     """Map watermark to BytePlus watermark field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform watermark into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["watermark"] = validated_value
-        return request
+    field = "watermark"
 
 
 __all__ = ["SizeMapper", "WatermarkMapper"]
diff --git a/src/celeste/providers/cohere/chat/parameters.py b/src/celeste/providers/cohere/chat/parameters.py
index 73d55f7f..e10433ad 100644
--- a/src/celeste/providers/cohere/chat/parameters.py
+++ b/src/celeste/providers/cohere/chat/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 RefResolvingJsonSchemaGenerator
 from celeste.types import TextContent
 
 
-class TemperatureMapper(ParameterMapper):
+class TemperatureMapper(FieldMapper):
     """Map temperature to Cohere 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 Cohere 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 ThinkingMapper(ParameterMapper):
diff --git a/src/celeste/providers/elevenlabs/text_to_speech/parameters.py b/src/celeste/providers/elevenlabs/text_to_speech/parameters.py
index d478fb7a..788d5050 100644
--- a/src/celeste/providers/elevenlabs/text_to_speech/parameters.py
+++ b/src/celeste/providers/elevenlabs/text_to_speech/parameters.py
@@ -3,10 +3,10 @@
 from typing import Any
 
 from celeste.models import Model
-from celeste.parameters import ParameterMapper
+from celeste.parameters import FieldMapper, ParameterMapper
 
 
-class VoiceMapper(ParameterMapper):
+class VoiceMapper(FieldMapper):
     """Map voice parameter to ElevenLabs URL path.
 
     Note: Voice ID goes in URL path, not request body.
@@ -14,17 +14,7 @@ class VoiceMapper(ParameterMapper):
     happens in _make_request().
     """
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform voice into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is not None:
-            request["_voice_id"] = validated_value
-        return request
+    field = "_voice_id"
 
 
 class OutputFormatMapper(ParameterMapper):
diff --git a/src/celeste/providers/google/interactions/parameters.py b/src/celeste/providers/google/interactions/parameters.py
index f966891a..c990a949 100644
--- a/src/celeste/providers/google/interactions/parameters.py
+++ b/src/celeste/providers/google/interactions/parameters.py
@@ -8,7 +8,7 @@
 
 from celeste.artifacts import ImageArtifact
 from celeste.models import Model
-from celeste.parameters import ParameterMapper
+from celeste.parameters import FieldMapper, ParameterMapper
 from celeste.types import TextContent
 
 
@@ -88,22 +88,10 @@ def map(
         return request
 
 
-class PreviousInteractionIdMapper(ParameterMapper):
+class PreviousInteractionIdMapper(FieldMapper):
     """Map previous_interaction_id for stateful conversations."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Add previous_interaction_id to request for conversation continuity."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["previous_interaction_id"] = validated_value
-        return request
+    field = "previous_interaction_id"
 
 
 class BackgroundMapper(ParameterMapper):
@@ -329,40 +317,16 @@ def map(
         return request
 
 
-class ResponseModalitiesMapper(ParameterMapper):
+class ResponseModalitiesMapper(FieldMapper):
     """Map response_modalities for multimodal output generation."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Set response modalities for output (e.g., IMAGE, TEXT)."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["response_modalities"] = validated_value
-        return request
+    field = "response_modalities"
 
 
-class SystemInstructionMapper(ParameterMapper):
+class SystemInstructionMapper(FieldMapper):
     """Map system_instruction for system prompts."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Add system instruction to request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["system_instruction"] = validated_value
-        return request
+    field = "system_instruction"
 
 
 __all__ = [
diff --git a/src/celeste/providers/gradium/text_to_speech/parameters.py b/src/celeste/providers/gradium/text_to_speech/parameters.py
index 0c4b5588..594f0b90 100644
--- a/src/celeste/providers/gradium/text_to_speech/parameters.py
+++ b/src/celeste/providers/gradium/text_to_speech/parameters.py
@@ -3,25 +3,13 @@
 from typing import Any
 
 from celeste.models import Model
-from celeste.parameters import ParameterMapper
+from celeste.parameters import FieldMapper, ParameterMapper
 
 
-class VoiceMapper(ParameterMapper):
+class VoiceMapper(FieldMapper):
     """Map voice to Gradium voice_id field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform voice into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["voice_id"] = validated_value
-        return request
+    field = "voice_id"
 
 
 class PaddingBonusMapper(ParameterMapper):
@@ -42,22 +30,10 @@ def map(
         return request
 
 
-class OutputFormatMapper(ParameterMapper):
+class OutputFormatMapper(FieldMapper):
     """Map output_format to Gradium 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"
 
 
 __all__ = [
diff --git a/src/celeste/providers/ollama/generate/parameters.py b/src/celeste/providers/ollama/generate/parameters.py
index a348cae5..b94a20fe 100644
--- a/src/celeste/providers/ollama/generate/parameters.py
+++ b/src/celeste/providers/ollama/generate/parameters.py
@@ -10,7 +10,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):
@@ -47,22 +47,10 @@ def map(
         return request
 
 
-class StepsMapper(ParameterMapper):
+class StepsMapper(FieldMapper):
     """Map steps to Ollama 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 SeedMapper(ParameterMapper):
@@ -83,22 +71,10 @@ def map(
         return request
 
 
-class NegativePromptMapper(ParameterMapper):
+class NegativePromptMapper(FieldMapper):
     """Map negative_prompt to Ollama negative_prompt field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform negative_prompt into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["negative_prompt"] = validated_value
-        return request
+    field = "negative_prompt"
 
 
 __all__ = [
diff --git a/src/celeste/providers/openai/audio/parameters.py b/src/celeste/providers/openai/audio/parameters.py
index e762b96c..4a9591b9 100644
--- a/src/celeste/providers/openai/audio/parameters.py
+++ b/src/celeste/providers/openai/audio/parameters.py
@@ -4,43 +4,19 @@
 
 from celeste.mime_types import AudioMimeType
 from celeste.models import Model
-from celeste.parameters import ParameterMapper
+from celeste.parameters import FieldMapper, ParameterMapper
 
 
-class VoiceMapper(ParameterMapper):
+class VoiceMapper(FieldMapper):
     """Map voice to OpenAI voice field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform voice into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["voice"] = validated_value
-        return request
+    field = "voice"
 
 
-class SpeedMapper(ParameterMapper):
+class SpeedMapper(FieldMapper):
     """Map speed to OpenAI speed field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform speed into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["speed"] = validated_value
-        return request
+    field = "speed"
 
 
 class ResponseFormatMapper(ParameterMapper):
@@ -80,22 +56,10 @@ def map(
         return request
 
 
-class InstructionsMapper(ParameterMapper):
+class InstructionsMapper(FieldMapper):
     """Map instructions to OpenAI instructions field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform instructions into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["instructions"] = validated_value
-        return request
+    field = "instructions"
 
 
 __all__ = [
diff --git a/src/celeste/providers/openai/images/parameters.py b/src/celeste/providers/openai/images/parameters.py
index ef82323d..ab6b4de0 100644
--- a/src/celeste/providers/openai/images/parameters.py
+++ b/src/celeste/providers/openai/images/parameters.py
@@ -1,153 +1,54 @@
 """OpenAI Images API parameter mappers."""
 
-from typing import Any
+from celeste.parameters import FieldMapper
 
-from celeste.models import Model
-from celeste.parameters import ParameterMapper
 
-
-class SizeMapper(ParameterMapper):
+class SizeMapper(FieldMapper):
     """Map size to OpenAI size field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform size into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["size"] = validated_value
-        return request
+    field = "size"
 
 
-class PartialImagesMapper(ParameterMapper):
+class PartialImagesMapper(FieldMapper):
     """Map partial_images to OpenAI partial_images field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform partial_images into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
+    field = "partial_images"
 
-        request["partial_images"] = validated_value
-        return request
 
-
-class QualityMapper(ParameterMapper):
+class QualityMapper(FieldMapper):
     """Map quality to OpenAI quality field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform quality into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["quality"] = validated_value
-        return request
+    field = "quality"
 
 
-class BackgroundMapper(ParameterMapper):
+class BackgroundMapper(FieldMapper):
     """Map background to OpenAI background field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform background into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
+    field = "background"
 
-        request["background"] = validated_value
-        return request
 
-
-class OutputFormatMapper(ParameterMapper):
+class OutputFormatMapper(FieldMapper):
     """Map output_format to OpenAI 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 StyleMapper(ParameterMapper):
+class StyleMapper(FieldMapper):
     """Map style to OpenAI style field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform style into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
+    field = "style"
 
-        request["style"] = validated_value
-        return request
 
-
-class ModerationMapper(ParameterMapper):
+class ModerationMapper(FieldMapper):
     """Map moderation to OpenAI moderation field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform moderation into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["moderation"] = validated_value
-        return request
+    field = "moderation"
 
 
-class OutputCompressionMapper(ParameterMapper):
+class OutputCompressionMapper(FieldMapper):
     """Map output_compression to OpenAI output_compression field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform output_compression into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["output_compression"] = validated_value
-        return request
+    field = "output_compression"
 
 
 __all__ = [
diff --git a/src/celeste/providers/openai/videos/parameters.py b/src/celeste/providers/openai/videos/parameters.py
index eb917280..951f55c1 100644
--- a/src/celeste/providers/openai/videos/parameters.py
+++ b/src/celeste/providers/openai/videos/parameters.py
@@ -3,7 +3,7 @@
 from typing import Any
 
 from celeste.models import Model
-from celeste.parameters import ParameterMapper
+from celeste.parameters import FieldMapper, ParameterMapper
 
 
 class SecondsMapper(ParameterMapper):
@@ -44,22 +44,10 @@ def map(
         return request
 
 
-class InputReferenceMapper(ParameterMapper):
+class InputReferenceMapper(FieldMapper):
     """Map input_reference to OpenAI input_reference field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform input_reference into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["input_reference"] = validated_value
-        return request
+    field = "input_reference"
 
 
 __all__ = [
diff --git a/src/celeste/providers/xai/images/parameters.py b/src/celeste/providers/xai/images/parameters.py
index 7d8670b7..2429db9f 100644
--- a/src/celeste/providers/xai/images/parameters.py
+++ b/src/celeste/providers/xai/images/parameters.py
@@ -6,64 +6,25 @@
 - The request key should match the provider's expected field name exactly
 """
 
-from typing import Any
+from celeste.parameters import FieldMapper
 
-from celeste.models import Model
-from celeste.parameters import ParameterMapper
 
-
-class AspectRatioMapper(ParameterMapper):
+class AspectRatioMapper(FieldMapper):
     """Map aspect_ratio to xAI aspect_ratio field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform aspect_ratio into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["aspect_ratio"] = validated_value
-        return request
+    field = "aspect_ratio"
 
 
-class NumImagesMapper(ParameterMapper):
+class NumImagesMapper(FieldMapper):
     """Map num_images to xAI n field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform num_images into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
+    field = "n"
 
-        request["n"] = validated_value
-        return request
 
-
-class ResponseFormatMapper(ParameterMapper):
+class ResponseFormatMapper(FieldMapper):
     """Map response_format to xAI response_format field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform response_format into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["response_format"] = validated_value
-        return request
+    field = "response_format"
 
 
 __all__ = [
diff --git a/src/celeste/providers/xai/videos/parameters.py b/src/celeste/providers/xai/videos/parameters.py
index fc0b7a2c..3a80504a 100644
--- a/src/celeste/providers/xai/videos/parameters.py
+++ b/src/celeste/providers/xai/videos/parameters.py
@@ -1,63 +1,24 @@
 """xAI Videos API parameter mappers."""
 
-from typing import Any
+from celeste.parameters import FieldMapper
 
-from celeste.models import Model
-from celeste.parameters import ParameterMapper
 
-
-class DurationMapper(ParameterMapper):
+class DurationMapper(FieldMapper):
     """Map duration to xAI duration field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform duration into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["duration"] = validated_value
-        return request
+    field = "duration"
 
 
-class AspectRatioMapper(ParameterMapper):
+class AspectRatioMapper(FieldMapper):
     """Map aspect_ratio to xAI aspect_ratio field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform aspect_ratio into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
+    field = "aspect_ratio"
 
-        request["aspect_ratio"] = validated_value
-        return request
 
-
-class ResolutionMapper(ParameterMapper):
+class ResolutionMapper(FieldMapper):
     """Map resolution to xAI resolution field."""
 
-    def map(
-        self,
-        request: dict[str, Any],
-        value: object,
-        model: Model,
-    ) -> dict[str, Any]:
-        """Transform resolution into provider request."""
-        validated_value = self._validate_value(value, model)
-        if validated_value is None:
-            return request
-
-        request["resolution"] = validated_value
-        return request
+    field = "resolution"
 
 
 __all__ = [
diff --git a/tests/unit_tests/test_client.py b/tests/unit_tests/test_client.py
index a98fe87f..5ec9e34c 100644
--- a/tests/unit_tests/test_client.py
+++ b/tests/unit_tests/test_client.py
@@ -42,7 +42,7 @@ def _create_test_mapper(
     class TestMapperClass(ParameterMapper):
         """Test mapper implementation."""
 
-        name: StrEnum = param_name
+        name = param_name
 
         def map(
             self,
@@ -72,7 +72,7 @@ def _create_transform_mapper(
     class TransformMapperClass(ParameterMapper):
         """Test mapper with output transformation."""
 
-        name: StrEnum = param_name
+        name = param_name
 
         def map(
             self,