@@ -11,7 +11,13 @@
 
 from dspy.clients.lm import LM
 from dspy.primitives import Example, Module, Prediction
-from dspy.teleprompt.gepa.gepa_utils import DspyAdapter, DSPyTrace, PredictorFeedbackFn, ScoreWithFeedback
+from dspy.teleprompt.gepa.gepa_utils import (
+    CodeProposalFn,
+    DspyAdapter,
+    DSPyTrace,
+    PredictorFeedbackFn,
+    ScoreWithFeedback,
+)
 from dspy.teleprompt.teleprompt import Teleprompter
 from dspy.utils.annotation import experimental
 
@@ -268,6 +274,21 @@ def metric(
             Note: When both instruction_proposer and reflection_lm are set, the instruction_proposer is called
             in the reflection_lm context. However, reflection_lm is optional when using a custom instruction_proposer.
             Custom instruction proposers can invoke their own LLMs if needed.
+        code_proposer: Optional custom proposer for `dspy.Flex` code components, implementing the
+            `CodeProposalFn` protocol from `dspy.teleprompt.gepa.gepa_utils`.
+            **Default: None** - Uses the built-in code proposer, which rewrites each Flex
+            submodule's full `module_src` from the failing examples and feedback.
+
+            A custom code proposer is called once per reflection round with the code components to
+            update, the current candidate, the reflective dataset, and per-component task
+            descriptions (the rendered Flex signature) and context blurbs (available tools and
+            style notes). It must return a complete replacement `dspy.Module` subclass source per
+            component. Like instruction_proposer, it is invoked inside the reflection_lm context
+            when one is set, and may invoke its own LM otherwise.
+
+            Only Flex components are routed to it; regular predictors keep going to
+            instruction_proposer (or the default instruction proposer). This parameter has no
+            effect on programs without `dspy.Flex` submodules.
         component_selector: Custom component selector implementing the [ReflectionComponentSelector](https://github.com/gepa-ai/gepa/blob/main/src/gepa/proposer/reflective_mutation/base.py) protocol,
             or a string specifying a built-in selector strategy. Controls which components (predictors) are selected
             for optimization at each iteration. Defaults to 'round_robin' strategy which cycles through components
@@ -365,6 +386,7 @@ def __init__(
         skip_perfect_score: bool = True,
         add_format_failure_as_feedback: bool = False,
         instruction_proposer: "ProposalFn | None" = None,
+        code_proposer: "CodeProposalFn | None" = None,
         component_selector: "ReflectionComponentSelector | str" = "round_robin",
         # Merge-based configuration
         use_merge: bool = True,
@@ -448,6 +470,7 @@ def __init__(
         self.seed = seed
 
         self.custom_instruction_proposer = instruction_proposer
+        self.custom_code_proposer = code_proposer
         self.component_selector = component_selector
         self.gepa_kwargs = gepa_kwargs or {}
 
@@ -590,6 +613,7 @@ def feedback_fn(
             rng=rng,
             reflection_lm=self.reflection_lm,
             custom_instruction_proposer=self.custom_instruction_proposer,
+            custom_code_proposer=self.custom_code_proposer,
             warn_on_score_mismatch=self.warn_on_score_mismatch,
             reflection_minibatch_size=self.reflection_minibatch_size,
         )
 
@@ -52,6 +52,25 @@ def log(self, x: str):
 """
 
 
+class CodeProposalFn(Protocol):
+    """Custom proposer for dspy.Flex code components.
+
+    The code-component counterpart of gepa's ProposalFn: called with the code components to
+    update plus the per-component task descriptions (rendered Flex signatures) and context
+    blurbs (available tools and style notes), under the reflection LM's context. Returns a
+    full replacement module source (one dspy.Module subclass) per component.
+    """
+
+    def __call__(
+        self,
+        candidate: dict[str, str],
+        reflective_dataset: dict[str, list[dict[str, Any]]],
+        components_to_update: list[str],
+        task_descriptions: dict[str, str],
+        context_blurbs: dict[str, str],
+    ) -> dict[str, str]: ...
+
+
 class ScoreWithFeedback(Prediction):
     score: float
     feedback: str
@@ -95,6 +114,7 @@ def __init__(
         rng: random.Random | None = None,
         reflection_lm=None,
         custom_instruction_proposer: "ProposalFn | None" = None,
+        custom_code_proposer: "CodeProposalFn | None" = None,
         warn_on_score_mismatch: bool = True,
         reflection_minibatch_size: int | None = None,
     ):
@@ -107,6 +127,7 @@ def __init__(
         self.rng = rng or random.Random(0)
         self.reflection_lm = reflection_lm
         self.custom_instruction_proposer = custom_instruction_proposer
+        self.custom_code_proposer = custom_code_proposer
         self.warn_on_score_mismatch = warn_on_score_mismatch
         self.reflection_minibatch_size = reflection_minibatch_size
         self._warned_custom_proposer_skips_code = False
@@ -124,23 +145,37 @@ def propose_new_texts(
     ) -> dict[str, str]:
         reflection_lm = self.reflection_lm or dspy.settings.lm
 
-        # dspy.Flex code components are rewritten by the code proposer.
+        # dspy.Flex code components are rewritten by the code proposer. A custom code proposer
+        # overrides the built-in one, mirroring how custom_instruction_proposer overrides the
+        # default instruction proposer below.
         results: dict[str, str] = {}
         code_keys = [c for c in components_to_update if c in self._flex_paths]
         if code_keys:
-            results.update(
-                propose_code(
-                    code_keys, candidate, reflective_dataset,
-                    self._flex_task_descriptions, self._flex_context_blurbs, reflection_lm,
+            if self.custom_code_proposer:
+                with dspy.context(lm=reflection_lm):
+                    results.update(
+                        self.custom_code_proposer(
+                            candidate=candidate,
+                            reflective_dataset=reflective_dataset,
+                            components_to_update=code_keys,
+                            task_descriptions=self._flex_task_descriptions,
+                            context_blurbs=self._flex_context_blurbs,
+                        )
+                    )
+            else:
+                results.update(
+                    propose_code(
+                        code_keys, candidate, reflective_dataset,
+                        self._flex_task_descriptions, self._flex_context_blurbs, reflection_lm,
+                    )
                 )
-            )
         components_to_update = [c for c in components_to_update if c not in self._flex_paths]
         if not components_to_update:
             return results
 
         # A custom proposer overrides the default *instruction* proposer only.
         if self.custom_instruction_proposer:
-            if code_keys and not self._warned_custom_proposer_skips_code:
+            if code_keys and not self.custom_code_proposer and not self._warned_custom_proposer_skips_code:
                 logger.warning(
                     "A custom instruction_proposer is set, but %d dspy.Flex code component(s) are "
                     "being optimized. The custom proposer handles instruction components only; the "
 
@@ -407,6 +407,102 @@ def forward(self, *args, **kwargs):
     assert out == {"self": original}
 
 
+# --- adapter: a custom code proposer overrides the built-in one ---------------
+
+
+def test_custom_code_proposer_overrides_builtin_and_receives_contract() -> None:
+    captured = {}
+
+    def code_proposer(*, candidate, reflective_dataset, components_to_update, task_descriptions, context_blurbs):
+        captured.update(
+            candidate=candidate,
+            reflective_dataset=reflective_dataset,
+            components_to_update=components_to_update,
+            task_descriptions=task_descriptions,
+            context_blurbs=context_blurbs,
+        )
+        return dict.fromkeys(components_to_update, SIMPLE_MODULE)
+
+    student = dspy.Flex(Echo)
+    adapter = DspyAdapter(
+        student_module=student,
+        metric_fn=_metric,
+        feedback_map={},
+        reflection_lm=DummyLM([]),  # empty: any call through the built-in proposer would fail
+        custom_code_proposer=code_proposer,
+    )
+    candidate = {"self": student.module_src}
+    reflective = {"self": [{"Inputs": {"q": "x"}, "Generated Outputs": "wrong", "Feedback": "bad"}]}
+
+    out = adapter.propose_new_texts(candidate, reflective, ["self"])
+
+    assert out == {"self": SIMPLE_MODULE}
+    assert captured["components_to_update"] == ["self"]
+    assert captured["candidate"] == candidate
+    assert captured["reflective_dataset"] == reflective
+    assert "self" in captured["task_descriptions"]
+    assert "self" in captured["context_blurbs"]
+
+
+def test_custom_code_proposer_runs_in_reflection_lm_context() -> None:
+    seen = {}
+    reflection = DummyLM([])
+
+    def code_proposer(*, candidate, reflective_dataset, components_to_update, task_descriptions, context_blurbs):
+        seen["lm"] = dspy.settings.lm
+        return dict.fromkeys(components_to_update, SIMPLE_MODULE)
+
+    student = dspy.Flex(Echo)
+    adapter = DspyAdapter(
+        student_module=student,
+        metric_fn=_metric,
+        feedback_map={},
+        reflection_lm=reflection,
+        custom_code_proposer=code_proposer,
+    )
+    adapter.propose_new_texts({"self": student.module_src}, {"self": []}, ["self"])
+    assert seen["lm"] is reflection
+
+
+def test_no_skip_warning_when_custom_code_proposer_handles_code(caplog) -> None:
+    """The 'custom instruction_proposer skips code components' warning exists because those
+    components would otherwise fall through to the built-in code proposer silently. With a
+    custom code proposer installed, nothing is skipped, so the warning must not fire."""
+
+    class Prog(dspy.Module):
+        def __init__(self):
+            super().__init__()
+            self.flex = dspy.Flex(Echo)
+            self.sibling = dspy.Predict("x -> y")
+
+        def forward(self, **kwargs):
+            return self.flex(**kwargs)
+
+    def instruction_proposer(*, candidate, reflective_dataset, components_to_update):
+        return dict.fromkeys(components_to_update, "new instruction")
+
+    def code_proposer(*, candidate, reflective_dataset, components_to_update, task_descriptions, context_blurbs):
+        return dict.fromkeys(components_to_update, SIMPLE_MODULE)
+
+    prog = Prog()
+    adapter = DspyAdapter(
+        student_module=prog,
+        metric_fn=_metric,
+        feedback_map={},
+        reflection_lm=DummyLM([]),
+        custom_instruction_proposer=instruction_proposer,
+        custom_code_proposer=code_proposer,
+    )
+    candidate = {"flex": prog.flex.module_src, "sibling": "old instruction"}
+    reflective = {"flex": [], "sibling": []}
+
+    with caplog.at_level("WARNING"):
+        out = adapter.propose_new_texts(candidate, reflective, ["flex", "sibling"])
+
+    assert out == {"flex": SIMPLE_MODULE, "sibling": "new instruction"}
+    assert not any("code component" in r.message for r in caplog.records)
+
+
 # --- GEPA.compile: seed mixes code + instruction components ------------------
 
 
@@ -448,6 +544,25 @@ def fake_optimize(**kwargs):
     assert not any(k.startswith("flex.") for k in seed)
 
 
+def test_gepa_compile_threads_code_proposer_to_adapter(monkeypatch) -> None:
+    captured = {}
+
+    def fake_optimize(**kwargs):
+        captured["adapter"] = kwargs["adapter"]
+        return _FakeResult(best_candidate=kwargs["seed_candidate"])
+
+    monkeypatch.setattr("gepa.optimize", fake_optimize)
+
+    def code_proposer(*, candidate, reflective_dataset, components_to_update, task_descriptions, context_blurbs):
+        return dict.fromkeys(components_to_update, SIMPLE_MODULE)
+
+    optimizer = dspy.GEPA(metric=_metric, reflection_lm=DummyLM([]), max_metric_calls=10, code_proposer=code_proposer)
+    ex = dspy.Example(q="x", a="y").with_inputs("q")
+    optimizer.compile(dspy.Flex(Echo), trainset=[ex], valset=[ex])
+
+    assert captured["adapter"].custom_code_proposer is code_proposer
+
+
 # --- DspyGEPAResult.to_dict: candidates keep their code components -----------