[Essam Gouda (egouda-colab)]

What

This PR makes SkillOpt usable as a library behind a caller's own model client, with no monkeypatching.

• skillopt.model.set_optimizer_chat(fn) / reset_optimizer_chat(). When a function is set, chat_optimizer and chat_optimizer_messages call it before any built-in backend.
• model.optimizer_backend: custom declares that the optimizer function comes from the caller.
• optimizer.strict_errors (default false). When it is on, an optimizer stage re-raises a failed call instead of silently using its fallback.
• Resume fix. A stored score of 0.0 is no longer read back as "unscored".

Why

Some library users must send every LLM call through their own client, for example to apply their own authentication, auditing, or data-governance controls. Today the provider dispatch is hard-coded, with Azure OpenAI as the fallback. So these users have to rebind chat_optimizer in every module that imports it by name (trainer, reflect, aggregate, clip, rewrite, meta_skill, slow_update, lr_autonomous) and stub the provider backends.

In that setup a broken client is also easy to miss. Optimizer failures are deliberately swallowed: reflect returns no edits, merge concatenates, and rank truncates. A run can therefore finish "successfully" with the skill unchanged.

API

import skillopt.model as model

def my_optimizer_chat(messages, *, stage, **options):
    reply = my_client.complete(messages)  # the caller's own client
    usage = {"prompt_tokens": reply.input_tokens, "completion_tokens": reply.output_tokens}
    return reply.text, usage

model.set_optimizer_chat(my_optimizer_chat)

model:
  optimizer_backend: custom   # fail fast if no function is registered
optimizer:
  strict_errors: true         # optional; default false

• Signature. The function takes the same arguments as chat_optimizer_messages: messages plus max_completion_tokens, retries, stage, reasoning_effort, tools, tool_choice, return_message and timeout. It returns (text, usage), or (message, usage) when return_message=True. chat_optimizer passes it the [system, user] messages.
• No changes to callers. The dispatchers look the function up on every call, so the existing from skillopt.model import chat_optimizer imports pick it up without any edit to those modules.
• Token accounting. Usage is recorded in get_token_summary(), so summary.json and the per-step token records stay complete.
• Fail fast. With custom set and no function registered, ReflACTTrainer.train() raises before any rollout runs, and a direct call raises RuntimeError. Neither falls through to Azure.
• No provider client for the optimizer. Provider clients are already created lazily, so a custom optimizer never creates or authenticates one. Target calls still follow model.target_backend.
• Where strict_errors applies. Every optimizer fallback honors it: reflect (error and success analysts), merge (batch and final), rank, autonomous LR, rewrite, slow update, meta skill and appendix consolidation. Only exceptions are re-raised. Output that comes back but can't be used still takes the existing fallbacks.

Backward compatibility

• Defaults are unchanged. With no function registered and strict_errors: false (the default), dispatch, fallbacks and outputs behave exactly as before. Tests that patch module.chat_optimizer keep working.
• custom is never overridden. It is a new optimizer-only value. It is not a role default, so model.backend / --backend role resolution leaves it in place.
• No new dependencies.
• Resume. Scores in runtime_state.json are now read with is None checks. Previously a stored current_score: 0.0 became -1.0, which re-ran the baseline selection evaluation and overwrote the best score. fix(trainer): improve checkpoint consistency on resume #253 makes an equivalent change as part of a broader checkpoint refactor. If that lands first, I'm happy to drop this hunk.

Tests

tests/test_custom_optimizer_chat.py:

• End-to-end routing. A tiny synthetic two-epoch training run (fake adapter, no network) sends every stage's call to a fake function: analyst, merge, lr_autonomous, ranking, slow_update and meta_skill. The test checks that no built-in provider client is created, the analyst's edit is applied, and the token summary counts every call.
• Argument passthrough for chat_optimizer and chat_optimizer_messages. A module that imported chat_optimizer by name (clip) uses the registered function.
• Default backends untouched. Built-in dispatch is unchanged when no function is registered, including after reset_optimizer_chat().
• Clear failure. custom with no function registered fails clearly, both on a direct call and in the trainer.
• Strict mode. With strict_errors on, a fake that raises propagates out of each stage (parametrized over all of them) and, through optimizer.strict_errors in the config, stops train(). With the default, the fallback still applies.

tests/test_trainer_resume.py:

• Resuming with a stored 0.0 doesn't re-run the baseline and keeps best_selection_hard == 0.0. This test fails on main.

Results:

• python -m pytest -q (Python 3.12): 2022 passed, 11 skipped, 4 xfailed.
• mkdocs build --strict passes.
• ruff check reports no new findings in the touched files.

Docs updated: docs/guide/new-backend.md (new section), docs/reference/config.md, docs/reference/api.md, configs/_base_/default.yaml and CHANGELOG.md.

Release question

The 0.2.0 wheel on PyPI doesn't include the prompt .md files, so the training loop can't run from a PyPI install. This is already fixed on main (see the Unreleased changelog, #135/#137). Would you consider publishing a 0.2.1 with that fix?

🤖 Generated with Claude Code