adapt-agent 0.3.2__tar.gz → 0.4.0__tar.gz

{adapt_agent-0.3.2 → adapt_agent-0.4.0}/CHANGELOG.md

@@ -7,6 +7,205 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-08-27
+
+### Added
+
+- **`verbose=True` now reports where a long run actually is, not just what it
+  found.** Per-trial logging showed a candidate's score with no sense of
+  position or pace -- indistinguishable, over a run measured in hours, from a
+  hang. Every optimizer's trial log now includes the trial's position out of
+  the run's evaluation budget and the wall-clock time elapsed since the run
+  started (`trial 5/60 score=0.7100 ACCEPT (142.3s elapsed)`), and the
+  baseline-start line states the budget up front
+  (`baseline score=0.4100 (search budget: up to 60 evals)`).
+  `PipelineOptimizer` -- which overrides `optimize()` entirely and so never
+  ran the base class's verbose logging for itself, only ever forwarding
+  `verbose` into each stage -- now also logs its own stage transitions
+  (`stage 2/4 (coordinate_ascent) starting: 15/60 evals used so far (203.1s
+  elapsed)`) and a completion summary, so a multi-stage `make_default_optimizer`
+  pipeline no longer reads as one unexplained pause between each stage's own
+  output.
+
+  `OptimizationResult` gained `duration_seconds` (wall-clock time for the
+  whole `optimize` call), appended at the end of the dataclass per its
+  append-only convention, surfaced in `to_dict()`, `repr()`, and the
+  provenance header `to_config()` writes to a tuned-config file.
+
+- **`OptimizableAgent` (and every `from_*` constructor, plus `wrap()`) gained
+  `exclude=` and `replace=`, so introspection catching up to a hand-bound
+  workaround no longer silently doubles a knob.** Parameters are opaque
+  getter/setter closures, so the library cannot detect that two of them target
+  the *same* underlying storage under *different* names — only that two names
+  collide, which already raised. The gap: a caller hand-binds a parameter to
+  work around introspection missing a knob (a real, documented, and until now
+  the *only* supported reason to declare extra parameters), a later release
+  teaches introspection to find that same knob under its own name, and the two
+  now coexist pointing at one piece of storage — doubling that part of the
+  search space and letting whichever knob an optimizer applies last silently
+  overwrite the other's candidate. Nothing raised, because the names never
+  matched.
+
+  `exclude={"agent.instructions", ...}` removes named introspected parameters
+  from the space before declared `parameters` are merged in — the fix for the
+  reported shape, where the hand-bound and introspected knobs have different
+  names. `replace=True` instead lets a declared parameter *under the same
+  name* as an introspected one win outright, for overriding how a knob with a
+  name you want to keep is read/written. The default collision behavior
+  (`ValueError`) is unchanged — an unintended same-name clash is still caught,
+  since `replace` is opt-in. New primitives underneath: `SearchSpace.remove(name)`
+  (drop a knob, never raises for a missing name) and `SearchSpace.add(parameter,
+  replace=True)`; `OptimizableAgent.add_parameter(parameter, replace=True)`
+  exposes the same override after construction.
+
+### Fixed
+
+- **A completion callable that could not accept `system=` made the judge
+  grade silently without its rubric.** Every judge call
+  (`score`/`critique`/`compare`/`improve_prompt`) sends the grading
+  rubric/instructions via `complete(prompt, system=...)`. A callable
+  conforming to the *documented* `CompletionFn` shape — a plain
+  `def f(prompt: str) -> str`, exactly the form shown in the quick-start
+  example — raises `TypeError` on that call, and both places that catch it
+  (`CallableProvider.complete`, and `LLMJudge._invoke` for a bare callable
+  passed directly) fell back to `complete(prompt)`, dropping the rubric with
+  no warning. The judge kept returning normal-looking scores, indistinguishable
+  from a working judge, while silently grading blind on every call — a search
+  can burn its entire budget on an oracle that was never actually applying the
+  rubric. Both fallback sites now emit a `logger.warning` naming the dropped
+  keyword and how to fix the callable's signature; behavior is otherwise
+  unchanged; nothing raises. `CompletionFn`'s type widened from
+  `Callable[[str], str]` to `Callable[..., str]` to stop documenting a
+  signature that silently loses information in practice.
+
+- **Optimizers stop paying for configurations they have already measured.**
+  Every optimizer now carries an evaluation cache (`cache_evaluations=True`)
+  keyed on the *live parameter state* at evaluation time, living for exactly
+  one `optimize` call. `PipelineOptimizer` injects one shared cache into its
+  stages -- and this is where the money was: each stage begins by evaluating
+  its baseline over the full dataset, and each stage's baseline *is* the
+  previous stage's winner, already measured. The default four-stage
+  `make_default_optimizer` pipeline was spending five full-dataset baseline
+  passes per run, four of them redundant; they are now cache hits. Keying on
+  the live state (not the candidate diff) is what makes those hits happen,
+  since a stage baseline and the winning trial that produced it reach the
+  same state through different configs.
+
+  The cost machinery this loop already had is deliberately untouched:
+  incomplete reports (rows lost to transient provider failures) are never
+  cached, so the baseline's re-run-on-incomplete path always re-measures, and
+  a cache hit still performs the restore/apply so proposers observe identical
+  live state either way. Live objects in the state (tool lists holding
+  callables) key by identity -- distinct-but-equal objects miss rather than
+  falsely hit, which only costs a re-run. Trial histories are unchanged:
+  cached trials record the same scores in the same order, so results are
+  byte-identical for a deterministic agent. Pass `cache_evaluations=False`
+  (per optimizer or per stage -- a stage's opt-out is respected inside a
+  caching pipeline) to re-measure every configuration, e.g. to average out a
+  stochastic agent.
+
+- **Every supported framework is now drivable through one entry point --
+  including the three whose agents cannot run themselves.** An OpenAI Agents
+  SDK `Agent` is a configuration object executed by `Runner.run_sync(agent,
+  input)`; a Claude Agent SDK setup is a `ClaudeAgentOptions` driven by
+  `query(prompt=..., options=...)`; a bare Google ADK agent runs inside a
+  session-holding `Runner`. `resolve_runner` knows none of that, so
+  `evaluate_agent(...)`, `framework_runner(...)` and
+  `OptimizableAgent.from_agent(...)` -- the documented "point it at your agent"
+  entry points -- raised `TypeError` for exactly these frameworks, and every
+  example hand-wrote the driving lambda the SDK documents anyway.
+
+  Two new runner builders close the gap, mirroring `adk_runner`:
+
+  - **`openai_agents_runner(agent, *, runner=None, run_kwargs=None,
+    output_extractor=...)`** drives the agent through the SDK's `Runner`
+    (imported lazily; inject anything with a compatible `run_sync` -- or an
+    async `run`, which is awaited -- for tests and custom runners), forwarding
+    `run_kwargs` (e.g. `max_turns`, a shared `context`) to every call.
+  - **`claude_agent_runner(options, *, query_fn=None, output_extractor=...)`**
+    drives `query`, draining the async message stream synchronously and
+    extracting the final `ResultMessage` text. The options object is closed
+    over, not copied -- so the runner always reads the *live* object the
+    introspected parameters mutate, which is exactly what optimization needs.
+
+  `framework_runner` now **delegates by detected framework** when an object
+  exposes no run method at all (OpenAI Agents -> `openai_agents_runner`,
+  Claude options -> `claude_agent_runner`, bare ADK agent -> `adk_runner`),
+  and `OptimizableAgent.from_agent` falls back to `framework_runner` when
+  `resolve_runner` finds nothing runnable. Directly-runnable frameworks are
+  untouched -- resolution is attempted first and wins, so existing behaviour
+  (including framework-native outputs) is byte-identical; the fallback only
+  replaces a `TypeError`, never a working runner. A missing SDK surfaces as an
+  `ImportError` naming the extra to install, which is strictly more useful
+  than the `TypeError` it replaces. Both builders are exported from
+  `adapt_agent.optimization` and `adapt_agent.evaluation`.
+
+- **Framework introspection reaches the knobs that steer multi-agent behaviour,
+  not just the ones on the front agent.** Two whole categories of tunable text
+  were invisible to the optimizer:
+
+  - *OpenAI Agents SDK*: an agent's `handoff_description` -- the text a routing
+    agent reads when deciding whether to delegate to it -- is now a PROMPT
+    parameter, and a `Handoff` **wrapper** in a `handoffs` list now contributes
+    its `tool_description` (as `<agent>_handoff.tool_description`). A wrapper
+    holds its agent inside an `on_invoke_handoff` closure, so the sub-agent
+    itself is structurally unreachable -- but the description is what the
+    routing LLM actually reads, and it is the part worth tuning. Previously a
+    topology built with `handoff(...)` lost the wrapped branch entirely, and
+    nothing tuned routing text anywhere.
+
+  - *Claude Agent SDK*: the subagent definitions in `options.agents` are now
+    introspected -- each definition's `prompt` and `description` (both
+    prompts: one steers the specialist, the other steers delegation *to* it),
+    its `model`, and its `tools`/`skills` lists (with the same drop-one
+    ablation candidates every other tool list gets), namespaced under the
+    slugged subagent name. Both real `AgentDefinition` objects and the plain
+    mappings the SDK also accepts are handled, and a subagent whose name
+    collides with the root component is skipped rather than allowed to produce
+    duplicate parameter names. The `agents` field was already recognised (it
+    stopped vetoing detection in 0.3.x) but its contents were never bound, so
+    a multi-agent Claude setup exposed only the orchestrator's knobs.
+
+- **Sampling knobs the frameworks expose but introspection didn't.** Each is
+  bound with the same duck-typing rules as its neighbours (only when present,
+  only when the value has the right shape): CrewAI LLM objects gain `top_p`;
+  Google ADK `generate_content_config` gains `top_k` (bounded (1, 40), valid
+  for every Gemini generation so a gridded candidate never becomes a runtime
+  rejection); Pydantic AI `model_settings` and Microsoft Agent Framework
+  agents/clients/`default_options` gain `frequency_penalty` and
+  `presence_penalty` (bounded (-2.0, 2.0)); LangGraph bound chat models gain
+  `top_p`.
+
+- **CrewAI `allow_delegation` is a searchable ROUTING parameter** with
+  `[True, False]` candidates -- whether an agent may hand work to its
+  crew-mates is a real topology decision the optimizer can now measure instead
+  of inherit. Bound only when the live value is a genuine `bool`.
+
+- **Microsoft Agent Framework: the model is found even when the client hides
+  it.** When none of the client's model attributes exist, the per-agent
+  `model_id` override in `default_options` now binds as the MODEL parameter
+  (the client still wins when both are present). Previously such an agent had
+  no model knob at all despite the identifier sitting in its options mapping.
+
+- **Claude Agent SDK: `max_thinking_tokens`** binds as a HYPERPARAM (bounds
+  (1024, 32000) -- the floor is the API's minimum thinking budget) on SDK
+  versions that carry it as a flat option.
+
+### Changed
+
+- **OpenAI Agents SDK `model_settings.max_tokens` now carries bounds
+  (1, 32000)**, like every other framework's max-tokens knob. Boundless, its
+  search space collapsed to the current value -- `enumerate_candidates()`
+  returned one option and the numeric proposer skipped it -- so it appeared in
+  every report as a parameter the optimizer could never actually move.
+
+- **CrewAI tasks with a `name` are namespaced under it** (slugged), falling
+  back to the positional `task_<index>` only when nameless. A name survives
+  reordering the task list; an index silently rebinds every exported tuned
+  config to a different task. A config exported before this release for a
+  *named* task addresses `task_<index>` and will no longer re-apply -- re-run
+  `to_config()` (unnamed tasks are unaffected).
+
 ## [0.3.2] - 2026-08-24
 
 ### Changed
@@ -67,6 +266,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   report its version and each has the same fix. A diagnostic that fails on a
   damaged file tells you least exactly when you need it most.
 
+### Fixed
+
+- **The evaluation cache could serve a report across two different
+  evaluators.** The cache key covered only the dataset identity and live
+  parameter state, so a `PipelineOptimizer` assembled from stages carrying
+  *different* harnesses (different metrics, a different judge) could let one
+  stage reuse a report another stage's harness produced, ranking candidates
+  against the wrong scores. The harness identity is now part of the key;
+  stages sharing one harness instance (how `make_default_optimizer` builds
+  pipelines) still share hits.
+- **A pipeline-level `cache_evaluations=False` didn't reach its stages.**
+  `PipelineOptimizer(..., cache_evaluations=False)` cleared the *shared*
+  cache, but a stage left at its own default (`True`) then built a private
+  per-stage cache anyway, so repeated configurations were still served from
+  cache instead of re-measured. The pipeline's opt-out now suppresses stage
+  caching for the run; a stage's own opt-out inside a caching pipeline is
+  still respected.
+- **Two CrewAI tasks with the same (or identically-slugged) `name` collided.**
+  0.3.2's task-naming-by-`name` change (below) could make two tasks emit the
+  same component (`research_task.description` for both), and constructing the
+  `OptimizableAgent` raised `ValueError: Duplicate parameter name`. Colliding
+  names are now disambiguated with the task's positional index, so upgrading
+  to named-task components can no longer break agents whose tasks share a
+  name.
+- **`PipelineOptimizer` assumed every stage carries a live `Optimizer`
+  state.** Cache injection read `stage._eval_cache` unconditionally, which
+  raised `AttributeError` for a minimal `Optimizer` subclass that
+  intentionally skips `Optimizer.__init__` (a pattern the cache's own read/
+  write helpers already tolerate via `getattr`). Stage attribute access is
+  now equally defensive.
+
 
 ## [0.3.1] - 2026-08-24
 
@@ -1861,7 +2091,9 @@ package that actually installs and is usable end to end.
   optimization, adversarial defense, evaluation, observability, patches, and the
   `adapt-agent` CLI (`info` command).
 
-[Unreleased]: https://github.com/CodeHalwell/ADAPT-Agent/compare/v0.3.1...HEAD
+[Unreleased]: https://github.com/CodeHalwell/ADAPT-Agent/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/CodeHalwell/ADAPT-Agent/compare/v0.3.2...v0.4.0
+[0.3.2]: https://github.com/CodeHalwell/ADAPT-Agent/releases/tag/v0.3.2
 [0.3.1]: https://github.com/CodeHalwell/ADAPT-Agent/releases/tag/v0.3.1
 [0.3.0]: https://github.com/CodeHalwell/ADAPT-Agent/releases/tag/v0.3.0
 [0.2.0]: https://github.com/CodeHalwell/ADAPT-Agent/compare/v0.1.0...v0.2.0

{adapt_agent-0.3.2 → adapt_agent-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adapt-agent
-Version: 0.3.2
+Version: 0.4.0
 Summary: ADAPT-Agent: Adversarial Defense & Policy Training for LLM Agents - A comprehensive library for LLM agent optimization and security
 Author-email: Daniel Halwell <danielhalwell@gmail.com>
 Maintainer-email: Daniel Halwell <danielhalwell@gmail.com>

{adapt_agent-0.3.2 → adapt_agent-0.4.0}/adapt_agent/__init__.py

@@ -4,7 +4,7 @@ ADAPT-Agent: Adversarial Defense & Policy Training for LLM Agents
 A comprehensive library for LLM agent optimization and security.
 """
 
-__version__ = "0.3.2"
+__version__ = "0.4.0"
 
 # Core exports
 # Framework adapters

{adapt_agent-0.3.2 → adapt_agent-0.4.0}/adapt_agent/evaluation/__init__.py

@@ -40,7 +40,13 @@ from adapt_agent.optimization.metrics import (
     regex_match,
     token_f1,
 )
-from adapt_agent.optimization.runners import adk_runner, framework_runner, langgraph_inputs
+from adapt_agent.optimization.runners import (
+    adk_runner,
+    claude_agent_runner,
+    framework_runner,
+    langgraph_inputs,
+    openai_agents_runner,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -209,4 +215,6 @@ __all__ = [
     "framework_runner",
     "langgraph_inputs",
     "adk_runner",
+    "openai_agents_runner",
+    "claude_agent_runner",
 ]

{adapt_agent-0.3.2 → adapt_agent-0.4.0}/adapt_agent/optimization/__init__.py

@@ -115,7 +115,13 @@ from adapt_agent.optimization.retry import (
     RetryPolicy,
     is_transient_error,
 )
-from adapt_agent.optimization.runners import adk_runner, framework_runner, langgraph_inputs
+from adapt_agent.optimization.runners import (
+    adk_runner,
+    claude_agent_runner,
+    framework_runner,
+    langgraph_inputs,
+    openai_agents_runner,
+)
 from adapt_agent.optimization.target import OptimizableAgent, wrap
 
 __all__ = [
@@ -175,6 +181,8 @@ __all__ = [
     "framework_runner",
     "langgraph_inputs",
     "adk_runner",
+    "openai_agents_runner",
+    "claude_agent_runner",
     # target
     "OptimizableAgent",
     "wrap",

{adapt_agent-0.3.2 → adapt_agent-0.4.0}/adapt_agent/optimization/introspection/claude_agent.py

@@ -15,6 +15,14 @@ string we bind it directly; when it is a mapping carrying an ``"append"`` key we
 bind that key so the appended instructions stay tunable while the preset itself
 is preserved.
 
+Subagents are covered too. ``options.agents`` maps a subagent name to a
+definition -- an ``AgentDefinition`` dataclass or an equivalent plain mapping --
+whose ``prompt`` and ``description`` are the prompts that steer the subagent and
+the delegation to it, alongside its own ``model``, ``tools`` and ``skills``.
+Each definition is introspected under its (slugged) subagent name, so a
+multi-agent Claude setup exposes every specialist's knobs, not just the
+orchestrator's.
+
 Importing this module registers the introspector under the ``"claude_agent"``
 key.
 """
@@ -69,6 +77,81 @@ def _predicate(obj: Any) -> bool:
         return False
 
 
+def _slug(text: Any) -> str | None:
+    """Slugify a subagent name (lowercase, spaces -> underscores). ``None`` if empty."""
+    if not isinstance(text, str):
+        return None
+    slug = text.strip().lower().replace(" ", "_")
+    return slug or None
+
+
+def _definition_params(definition: Any, component: str) -> list[Parameter]:
+    """Bind one subagent definition's tunable fields.
+
+    A definition is an ``AgentDefinition`` dataclass in the real SDK, but the
+    SDK also accepts plain mappings, so both shapes are handled: attributes for
+    objects, keys for mappings. ``prompt`` and ``description`` are both PROMPT
+    knobs -- the prompt steers what the subagent does, the description steers
+    when the orchestrator delegates to it -- and ``tools``/``skills`` get the
+    same drop-one ablation candidates as every other tool list so subagent tool
+    selection is a real search space.
+    """
+    is_mapping = isinstance(definition, dict)
+
+    def _value(field: str) -> Any:
+        return definition.get(field) if is_mapping else getattr(definition, field, None)
+
+    def _bind(
+        field: str, name: str, kind: ParameterKind, candidates: list[Any] | None = None
+    ) -> Parameter | None:
+        if is_mapping:
+            return bind_item(
+                definition, field, name, kind, component=component, candidates=candidates
+            )
+        return bind_attr(definition, field, name, kind, component=component, candidates=candidates)
+
+    params: list[Parameter] = []
+    for field in ("prompt", "description"):
+        if isinstance(_value(field), str):
+            param = _bind(field, f"{component}.{field}", ParameterKind.PROMPT)
+            if param is not None:
+                params.append(param)
+    if isinstance(_value("model"), str):
+        param = _bind("model", f"{component}.model", ParameterKind.MODEL)
+        if param is not None:
+            params.append(param)
+    for field, kind in (("tools", ParameterKind.TOOL), ("skills", ParameterKind.SKILL)):
+        current = _value(field)
+        if isinstance(current, (list, tuple)):
+            param = _bind(
+                field, f"{component}.{field}", kind, tool_subset_candidates(current) or None
+            )
+            if param is not None:
+                params.append(param)
+    return params
+
+
+def _introspect_subagents(obj: Any, params: list[Parameter]) -> None:
+    """Introspect the subagent definitions in ``options.agents``.
+
+    Each definition is namespaced under its slugged dict key. Names already
+    emitted are skipped rather than duplicated -- a subagent literally named
+    ``"agent"`` would otherwise collide with the root component's own knobs and
+    make ``SearchSpace.add`` raise downstream.
+    """
+    definitions = getattr(obj, "agents", None)
+    if not isinstance(definitions, dict):
+        return
+    seen = {p.name for p in params}
+    for index, (key, definition) in enumerate(definitions.items()):
+        component = _slug(key) or f"subagent_{index}"
+        for param in _definition_params(definition, component):
+            if param.name in seen:
+                continue
+            seen.add(param.name)
+            params.append(param)
+
+
 def _introspect_system_prompt(obj: Any, component: str) -> list[Parameter]:
     """Bind the ``system_prompt`` (string, or preset mapping with ``"append"``)."""
     prompt = getattr(obj, "system_prompt", None)
@@ -137,6 +220,16 @@ def _introspect(obj: Any) -> list[Parameter]:
                 component=component,
                 bounds=(1, 100),
             ),
+            # The extended-thinking budget (present on SDK versions that carry
+            # it as a flat option). The floor matches the API's minimum budget.
+            bind_attr(
+                obj,
+                "max_thinking_tokens",
+                f"{component}.max_thinking_tokens",
+                ParameterKind.HYPERPARAM,
+                component=component,
+                bounds=(1024, 32000),
+            ),
             # ``permission_mode`` is a small discrete enum; giving it explicit
             # candidates turns it from a dead knob into a searchable one.
             bind_attr(
@@ -149,6 +242,8 @@ def _introspect(obj: Any) -> list[Parameter]:
             ),
         ]
         params.extend(p for p in candidates if p is not None)
+
+        _introspect_subagents(obj, params)
     except Exception:
         return params
     return params

{adapt_agent-0.3.2 → adapt_agent-0.4.0}/adapt_agent/optimization/introspection/crewai.py

@@ -8,9 +8,12 @@ importing ``crewai``: everything is discovered by duck-typing with ``getattr``.
 
 For each agent we expose its ``role``/``goal``/``backstory`` prompts, its model
 (a string identifier, or an introspected LLM object's
-``model``/``temperature``/``max_tokens``), its ``tools`` allow-list, and its
-``max_iter`` hyperparameter. For each task we expose its ``description`` and
-``expected_output`` prompts.
+``model``/``temperature``/``top_p``/``max_tokens``), its ``tools`` allow-list,
+its ``max_iter`` hyperparameter, and its ``allow_delegation`` routing switch
+(with ``[True, False]`` candidates, so the optimizer can search whether letting
+the agent delegate helps or hurts). For each task we expose its ``description``
+and ``expected_output`` prompts, named after the task's ``name`` when it has one
+(falling back to the positional ``task_<index>``).
 
 Importing this module registers the introspector under the ``"crewai"`` key.
 """
@@ -76,6 +79,14 @@ def _introspect_llm(llm: Any, component: str) -> list[Parameter]:
             component=component,
             bounds=(0.0, 2.0),
         ),
+        bind_attr(
+            llm,
+            "top_p",
+            f"{component}.top_p",
+            ParameterKind.HYPERPARAM,
+            component=component,
+            bounds=(0.0, 1.0),
+        ),
         bind_attr(
             llm,
             "max_tokens",
@@ -144,12 +155,55 @@ def _introspect_agent(agent: Any, index: int) -> list[Parameter]:
     if max_iter is not None:
         params.append(max_iter)
 
+    # ``allow_delegation`` decides whether this agent may hand work to its
+    # crew-mates -- a routing switch, and with explicit candidates a genuinely
+    # searchable one: the optimizer can measure whether delegation helps or
+    # just adds hops. Bound only when it is a real bool, so a Mock-ish or
+    # unset attribute never turns into a knob.
+    if isinstance(getattr(agent, "allow_delegation", None), bool):
+        delegation = bind_attr(
+            agent,
+            "allow_delegation",
+            f"{component}.allow_delegation",
+            ParameterKind.ROUTING,
+            component=component,
+            candidates=[True, False],
+        )
+        if delegation is not None:
+            params.append(delegation)
+
     return params
 
 
-def _introspect_task(task: Any, index: int) -> list[Parameter]:
-    """Introspect a single CrewAI ``Task``."""
-    component = f"task_{index}"
+def _unique_component(component: str, index: int, used: set[str]) -> str:
+    """Return ``component``, suffixed with the positional index while taken.
+
+    Two tasks may share a name (or names that slug identically), and a name
+    can even slug to another task's positional fallback. Identical components
+    would emit identical parameter names -- a duplicate ``SearchSpace`` entry
+    downstream -- where the positional components could never collide. The
+    index is unique per task, so one suffix round settles ordinary collisions;
+    the loop covers a name crafted to match the suffixed form as well.
+    """
+    candidate = component
+    while candidate in used:
+        candidate = f"{candidate}_{index}"
+    used.add(candidate)
+    return candidate
+
+
+def _introspect_task(task: Any, index: int, used: set[str]) -> list[Parameter]:
+    """Introspect a single CrewAI ``Task``.
+
+    A task with a ``name`` is namespaced under it (slugged): the name survives
+    reordering the task list, where a positional ``task_<index>`` silently
+    rebinds every exported config to a different task. Nameless tasks keep the
+    positional fallback, and a component already claimed by an earlier task is
+    disambiguated with the positional index (see :func:`_unique_component`).
+    """
+    component = _unique_component(
+        _slug(getattr(task, "name", None)) or f"task_{index}", index, used
+    )
     candidates = [
         bind_attr(
             task,
@@ -176,9 +230,10 @@ def _introspect(obj: Any) -> list[Parameter]:
         agents = getattr(obj, "agents", None) or []
         for i, agent in enumerate(agents):
             params.extend(_introspect_agent(agent, i))
+        used_task_components: set[str] = set()
         tasks = getattr(obj, "tasks", None) or []
         for i, task in enumerate(tasks):
-            params.extend(_introspect_task(task, i))
+            params.extend(_introspect_task(task, i, used_task_components))
     except Exception:
         return params
     return params

{adapt_agent-0.3.2 → adapt_agent-0.4.0}/adapt_agent/optimization/introspection/google_adk.py

@@ -13,9 +13,9 @@ importing ``google.adk``: everything is discovered by duck-typing with
 For each agent we expose its ``instruction`` and ``global_instruction`` prompts
 (only when they are plain strings), its model (a string identifier, or an
 introspected model object's ``model``/``model_name``), the
-``temperature``/``top_p``/``max_output_tokens`` hyperparameters from its
-``generate_content_config``, its ``tools`` allow-list, and its ``sub_agents``
-routing list. Nested ``sub_agents`` are introspected recursively and namespaced
+``temperature``/``top_p``/``top_k``/``max_output_tokens`` hyperparameters from
+its ``generate_content_config``, its ``tools`` allow-list, and its
+``sub_agents`` routing list. Nested ``sub_agents`` are introspected recursively and namespaced
 under their own component names; an ``id()`` visited set guards against cycles.
 
 Importing this module registers the introspector under the ``"google_adk"`` key.
@@ -94,6 +94,16 @@ def _introspect_generate_config(config: Any, component: str) -> list[Parameter]:
             component=component,
             bounds=(0.0, 1.0),
         ),
+        # Kept within (1, 40): valid for every Gemini generation, so a gridded
+        # candidate never turns into a runtime rejection mid-search.
+        bind_attr(
+            config,
+            "top_k",
+            f"{component}.top_k",
+            ParameterKind.HYPERPARAM,
+            component=component,
+            bounds=(1, 40),
+        ),
         bind_attr(
             config,
             "max_output_tokens",

{adapt_agent-0.3.2 → adapt_agent-0.4.0}/adapt_agent/optimization/introspection/langgraph.py

@@ -186,6 +186,16 @@ def _model_params(runnable: Any, component: str) -> list[Parameter]:
             bounds=(0.0, 2.0),
         )
     )
+    params.append(
+        bind_attr(
+            model,
+            "top_p",
+            f"{component}.top_p",
+            ParameterKind.HYPERPARAM,
+            component=component,
+            bounds=(0.0, 1.0),
+        )
+    )
     params.append(
         bind_attr(
             model,

{adapt_agent-0.3.2 → adapt_agent-0.4.0}/adapt_agent/optimization/introspection/microsoft_agent_framework.py

@@ -118,6 +118,8 @@ _HYPERPARAMS: tuple[tuple[str, tuple[float, float]], ...] = (
     ("temperature", (0.0, 2.0)),
     ("top_p", (0.0, 1.0)),
     ("max_tokens", (1, 32000)),
+    ("frequency_penalty", (-2.0, 2.0)),
+    ("presence_penalty", (-2.0, 2.0)),
 )
 
 
@@ -220,6 +222,7 @@ def _introspect(obj: Any) -> list[Parameter]:
             params.append(instructions)
 
         client = _client_of(obj)
+        found_model = False
         if client is not None:
             for attr in _MODEL_ATTRS:
                 model = bind_attr(
@@ -231,9 +234,26 @@ def _introspect(obj: Any) -> list[Parameter]:
                 )
                 if model is not None:
                     params.append(model)
+                    found_model = True
                     break
             params.extend(_introspect_hyperparams(client, component))
 
+        # A per-agent model override can live in ``default_options`` ("model_id"
+        # is a ChatOptions key) rather than on the client -- for a client that
+        # exposes no model attribute at all, this is the only place the model
+        # is tunable from.
+        if not found_model:
+            model = bind_mapping_key(
+                obj,
+                _OPTIONS_ATTR,
+                "model_id",
+                f"{component}.model",
+                ParameterKind.MODEL,
+                component=component,
+            )
+            if model is not None:
+                params.append(model)
+
         # Sampling settings may live on the agent itself, or in its options
         # mapping, rather than on the client. First source found wins per knob.
         seen = {p.name for p in params}