effGen 1.3.0 — how a run ends

Nothing was removed or renamed. Most of these change how a run ends or how a tool call is read rather than what your code has to call; where a setting restores the 1.2.0 behaviour, the change shows it.

1. Change 01

   A run that stops making progress is asked for its answer — max_turns_without_progress defaults to 2

   It was None. After two turns in a row that bring no new tool result, the next turn offers no tools and asks for the answer. A turn that declares no action after a result — Action: None, Action: (continue reasoning) or another bracketed placeholder that names no tool the agent holds — is asked at once. Before the run's first result, only a turn whose every call was declined counts. A run that would have stopped on loop_detected, repeated_tool_result, max_iterations_* or null_final_from_model while holding tool results gets one closing request: its own calls and results, with no tools, whose reply is the answer. When that reply is an answer the run succeeds, with metadata["answer_source"] == "closing_request", so a run that raised RunStoppedError in 1.2.0 under the default raise_on_error=True can now return an answer. A closing reply that is a call, or a program for a code tool the agent holds, is not taken as the answer; after a program the run carries on, so such a run can send one model call more than max_iterations.

   python Copy

   from effgen import AgentConfig
   
   config = AgentConfig(model="openai:gpt-5-nano", max_turns_without_progress=None)   # 1.2.0's loop

   run(max_turns_without_progress=None) restores it for one call.

2. Change 02

   A run whose tool keeps failing ends tool_failed

   A tool that fails on its own side — a connection error, a timeout, an HTTP 5xx or 429, missing credentials — three times in a row, or whose circuit breaker is open, is unavailable for the rest of the run. A run left with no usable tool and no result now stops with the new stop reason tool_failed, which is in STOPPED_REASONS and raises RunStoppedError under the default raise_on_error=True. In 1.2.0 the run went on and returned whatever the model wrote, often a statement that it could not get the information. Such a run gets no closing request: it reports the tool's failure, typed, with metadata["error"]["kind"] == "tool", and metadata["unavailable_tools"] names the tools. The per-tool circuit breaker now counts only those tool-side failures, so a tool given bad input by the model is no longer refused to later calls and later runs, and a call retried after a tool-side failure is a retry, not a repeated call.

   python Copy

   from effgen import RunStoppedError
   
   try:
       response = agent.run("What is the weather in Paris?")
   except RunStoppedError as exc:   # stop_reason "tool_failed" when the tool kept failing
       print("stopped:", exc)

   Or pass raise_on_error=False and branch on response.termination == "tool_failed".

3. Change 03

   AgentResponse.termination says how a run ended

   "done" (the model answered), "not_possible" (the model answered, but every call was declined, failed on the tool's side or returned nothing — usually an answer saying the task cannot be done with these tools), "stuck" (the run kept proposing work that brought nothing new and wrote no answer), "tool_failed" and "error" (the run could not be carried out). to_dict() carries it, and a saved run read back reports the same value. A run whose calls reached a tool that rejected their input used the tool, and its answer is "done". Alongside it, metadata["tool_results"] counts a run's attempted, usable and input-rejected calls. A stopped run's partial never carries a tool's error message; a run whose only observations were errors has partial=None.

4. Change 04

   A tool call is read before it is reported — recover_lost_tool_calls defaults to True

   It was False. A tool call written as a Python literal, with raw line breaks inside its JSON, with unescaped double quotes inside a string value, with its last string closed one bracket early, or as a whole object followed by text inside its tag, now runs instead of ending the run with written_tool_call. A call nothing can read is sent back once, with a call required where the provider supports it. When the agent holds exactly one code-execution tool, a program in a fenced block before an empty call tag runs as that call. Under either setting, arguments that arrive as a string are read (as keywords, as an object's JSON, or as a raw value) and tool_calls records carry the decoded arguments; a call missing a required argument is not dispatched and is asked for again; and positional values are named in the tool's parameter order, while a call with more values than the tool has parameters carries no arguments and is asked for again.

   python Copy

   from effgen import AgentConfig
   
   config = AgentConfig(model="openai:gpt-5-nano", recover_lost_tool_calls=False)   # 1.2.0's reader

   Some runs make more tool calls: the calls the model meant to make now run. Delegated sub-agents inherit the setting.

5. Change 05

   A failed tool call is retried, bounded, and never an answer

   Two calls whose different inputs a tool rejects in the same words are no longer a repeated result, so they no longer withdraw the run's tools. Four failures in a row on a tool's input withdraw it for the run; a run left with no tool is asked for its answer, and ends tool_failed with metadata["error"]["kind"] == "input" when it writes none, where it used to go round to max_iterations. An answer that is a tool's error message is not a success: it is sent back once, and given again the run stops with null_final_from_model. A failed call no longer earns "you have the answer from the tool" near the iteration cap, and the direct calculator result is never a failure.

6. Change 06

   Served and local models are measured once for how they use a tool

   At tool_calling_mode="auto", the first agent with tools built for a model served behind a base_url, or run on a local engine, runs a short probe: questions about fictional things, answerable only through a stub search tool, as ordinary agent runs. A model that answers from memory while holding a search tool has its information-retrieval tools made must-call; a model whose native calls the server does not carry back is run in the ReAct text frame. Both follow only when you left the setting unset, and calculator and code tools are never moved. The result is stored in ~/.effgen/capabilities.json (or under $EFFGEN_HOME, or at $EFFGEN_CAPABILITY_CACHE), read by every later agent across processes, and measured again when the weights, the chat template, the endpoint or the probe change, and after 30 days. A probe is bounded at 48 requests and 120 seconds; one that cannot run stores nothing and logs one warning. response.metadata["tool_calling"] says which strategy a run used and why. The same store remembers a provider that rejects stop sequences beside tool definitions, where 1.2.0 reported the provider's HTTP 400, and a server that rejects reasoning_effort.

   python Copy

   from effgen import AgentConfig
   
   config = AgentConfig(
       model="Qwen/Qwen2.5-1.5B-Instruct",
       base_url="http://127.0.0.1:8000/v1",
       capability_probe=False,   # or EFFGEN_CAPABILITY_PROBE=0
   )

   An explicit tool_calling_mode or tool_use also keeps the declared behaviour, and first-party cloud adapters are never probed. A test suite that scripts a served endpoint sees the probe's requests first unless it sets one of these.

7. Change 07

   reasoning_effort reaches a model behind base_url, and Groq

   A reasoning_effort you set is now sent by the OpenAI-compatible adapter, whatever the model is called, and by the Groq adapter for a model its catalog marks as reasoning; in 1.2.0 both dropped it. A server that refuses the field costs one retry, once, and is remembered. Every other adapter that drops a reasoning_effort you set now says so once per model at WARNING level.

8. Change 08

   One agent serves overlapping conversations without mixing them

   run(session=...), run_async(session=...) and stream(session=...) hold their conversation on the call, not on the shared agent, so overlapping calls on one agent — threads, run_async() tasks, streams — each read and record only their own session. In 1.2.0 they swapped agent.session and agent.short_term_memory on the shared object, so overlapping calls could read and record each other's turns. Inside a call, agent.session and agent.short_term_memory still name that call's conversation; outside one, they are the agent's own. Per-call middleware applies to that call only. stream() now honours session=, where 1.2.0 ignored it, and a run whose input a guardrail blocks leaves the agent's session as it was.

   No code has to change. Calls without session= still share the agent's own memory, as before.

9. Change 09

   A streamed turn is saved to the agent's bound session

   On an agent created with session_id=, or given agent.session, stream() now appends each answered turn to that session and saves it, as run() always did. In 1.2.0 streamed turns stayed in memory and were missing from the session file, so a later process continuing the conversation never saw them.

10. Change 10

    Smaller changes

    effgen code --json reports a tool_failed run as stopped, as the library does. The OpenAI SDK's response types are built once when the adapter loads, so the first concurrent streams in a fresh process no longer fail with 'BaseModel' has no attribute '__pydantic_core_schema__'. The agent's circuit breaker keeps every first failure when several calls fail on one tool at once, and no longer raises dictionary changed size during iteration under concurrent writers.

Nothing was removed or renamed. Most of these change what a run reports or what a request carries rather than what your code has to call; where code does change, the change carries it.

1. Change 01

   A tool result the model writes itself is never taken as the answer

   On a model with native tool calling, the default hybrid strategy also reads a tool call written out as text (Action: / Action Input:). A model that does that can go on to write the tool's result itself, which used to end the run as a final answer from a tool that never ran. A turn that holds tools and whose reply may be read as text is now sent one stop sequence, "\nObservation:", where 1.1.0 sent four labels; a tool-free turn is sent none, and a caller's own stop_sequences replace it. When a reply holds a written action anyway, the action runs and whatever the model wrote after it is discarded. BaseModel.supports_stop_with_tools() is new: an adapter for a provider that rejects stop beside tools answers False, and the framework then cuts the returned text itself.

   A caller who relied on "\nQuestion:", "\nHuman:" or "\nUser:" stopping a tool-holding turn passes them in stop_sequences. A long answer containing a line that begins Question: is no longer cut there.

2. Change 02

   reasoning_effort reaches run() and run_async()

   In 1.1.0 it reached a streamed turn and not a blocking one. run(), run_async() and stream() now all send it when the caller passes it and the model declares that it reasons, and so does the blocking follow-up turn inside a stream. On a reasoning model this changes how long the answer is; on any other model the adapter drops it.

3. Change 03

   The output budget follows what the run declared

   When the caller pins no max_tokens, a run that declares an output_schema asks for a budget sized from the schema — a one-integer schema asks for 256 tokens rather than 1,024 — and a model that declares it reasons is never sent fewer than 4,096. A published maximum caps either. An explicit max_tokens, on the call or on AgentConfig, still wins on every call the run makes.

   Where a model would have written more than a schema-sized budget, the answer is now cut at the budget with the existing typed truncation message.

4. Change 04

   A request carries less of the framework's own text

   The tool contracts no longer ask for text the task did not ask for: the lookup contract's request to name what is missing, and the computation contract's request to work step by step and restate the answer, are gone. The tool contract comes before the caller's task, so the task is the last thing the model reads. Tool rules are stated once, a tool result identical to one the request already carries is written once and referred back to, and how fully a tool is described comes from the adapter through the new BaseModel.prompt_detail(). A run with no tools, or with tool_contract="", is unaffected.

   Only the rendering changes: a step keeps the whole tool result, so nothing stored, checkpointed or read back differs. AgentConfig(answer_style=...) is the way to ask for a shorter or a fuller answer.

5. Change 05

   On a provider with a prompt cache, a run keeps one request shape

   A run with tools sends its conversation as messages from its first run when memory is on, prompt_protocol is "auto" and the provider's adapter declares a prompt cache and takes messages, so a session's next question extends the cached prefix instead of starting a new one. The turn that asks for the answer keeps the same messages and tool definitions with tool_choice="none" where the adapter can forbid a call. AgentConfig.cache_system_prompt and cache_tools now work on Anthropic. Cached tokens are read on Groq, Together, Fireworks, Cerebras and Gemini, and priced at the provider's cached rate where the model catalog carries one; the ledger gains cache_write_tokens.

   python Copy

   from effgen import AgentConfig
   
   config = AgentConfig(model="openai:gpt-5-nano", prompt_protocol="flat")

   A reader that sums prompt tokens sees no change: cached tokens are part of prompt_tokens, not added to it. prompt_protocol="flat" keeps a run's own steps in one string.

6. Change 06

   The loop stops fewer runs that are still finding things

   A tool whose calls keep returning new results is no longer withdrawn after 12 calls (16 for a data-processing tool); it is withdrawn after that many calls in a row that brought nothing new, and a run that keeps finding things is bounded by max_iterations. run(max_iterations=N) now moves the loop's own thresholds too. Action: None is read as no action rather than as a call to a tool named None. A run that only repeats itself ends exactly as before.

7. Change 07

   Groq hands a tool call it could not parse back to the loop

   When a request carried tools and Groq answers that it could not parse the model's tool call, the adapter returns the call as the model wrote it instead of failing the run. The loop runs it if it can read it and otherwise asks for it again; the call's usage is estimated and recorded.

8. Change 08

   A spent cap refuses only calls that cost money, and says so with a typed error

   Once a configured spend cap is spent, a call to a local engine, a free tier or a server reached with base_url= is no longer refused. A refused call raises BudgetExceededError from run() whatever raise_on_error says, where 1.1.0 raised RuntimeError or returned a failed response. stream() raises it, run_batch() raises and stops, the server answers HTTP 429 with budget_exceeded, and effgen run --json prints the error document. No request reaches the provider.

   python Copy

   from effgen import BudgetExceededError
   
   try:
       response = agent.run("Summarise the report.")
   except BudgetExceededError as exc:   # not a RuntimeError
       print("spend cap reached:", exc)

9. Change 09

   A model with no published price reads as unknown, not as free

   CostTracker.total_cost() returns None when every call it covers was unpriced; it returned 0.0. CostEvent.cost_usd, RunLedger.cost_usd, total_cost_usd in effgen cost --json and cost_usd in the run executions and topology can all be None for the same reason. A free model still reads 0.0. A server reached with base_url= now records as openai_compatible, where 1.1.0 recorded openai, so an existing ledger file shows the same served model under both names across the upgrade.

   Treat None as "not priced" wherever you add up cost.

10. Change 10

    Every run keeps a ledger, and two totals changed with it

    response.ledger and response.metadata["ledger"] carry the run's RunLedger; the flat metadata keys are unchanged. Children — sub-agents, workflow nodes, team members, an agent run inside a tool — are attached once, and total() adds them up. effgen_model_call_latency_seconds now observes each model call rather than each run's wall time, and a decomposed run's tokens_used includes its sub-agents' tokens, while effgen_tokens_used_total takes only the run's own calls. A synchronous @tool runs in the caller's context, so an agent it starts is a child of the run.

    python Copy

    from effgen import Agent, AgentConfig
    from effgen.tools.builtin import Calculator
    
    agent = Agent(AgentConfig(
        model="Qwen/Qwen2.5-1.5B-Instruct",
        base_url="http://127.0.0.1:8000/v1",
        tools=[Calculator()],
    ))
    response = agent.run("What is 17 * 23?")
    ledger = response.ledger
    
    print(response.output)
    print(ledger.llm_calls, ledger.tool_calls, ledger.prompt_tokens, ledger.completion_tokens)
    print(f"model {ledger.model_wait_s:.2f} s, tools {ledger.tool_wait_s:.3f} s, "
          f"framework {ledger.framework_s * 1000:.1f} ms")
    print(ledger.cost_usd)   # None: a model you serve yourself has no published price

11. Change 11

    A run's reported time includes the work after the model's last answer

    execution_time now includes after_run middleware, the session save and the final checkpoint, and equals the ledger's wall_s.

12. Change 12

    The spend ledger stops growing at 250,000 rows

    At that size the ledger file folds its oldest rows into per-model totals, keeping every total exact. EFFGEN_COST_MAX_ROWS sets the ceiling, and 0 keeps every row. Opening an existing file adds two columns, calls and unpriced_calls, and rows in effgen cost --json gain unpriced_requests. A write that triggers a fold waits for it.

13. Change 13

    A server named with openai: gets the id without the prefix, and a streamed call keeps its own arguments

    AgentConfig(model="openai:<id>", base_url=...) now sends <id>; 1.1.0 sent the prefix and the server answered that the model does not exist. Concurrent streamed runs no longer hand a tool another stream's arguments. In-process local engines serve concurrent agents: several agents can share one in-process vLLM engine, concurrent GGUF runs no longer crash, and a GGUF run reuses its cache across turns.

14. Change 14

    An out-of-budget failure says what to do and is not retried

    A reply cut off by its token budget, or one that spent the whole budget reasoning, now carries its own guidance and is not marked retryable. It used to read "Unexpected provider error" and be retried.

Nothing was removed or renamed. Most of these change what a run reports or what a request carries rather than what your code has to call; where code does change, the change carries it.

1. Change 01

   A run carries its conversation, and response.metadata is no longer plain data

   AgentResponse.thread is the run's AgentThread, or None for a run that recorded none, and response.metadata["thread"] holds the same live object. The thread opens with the run's frame — a SystemStep when tools are attached, then always a TaskStep — so thread.steps[0] is no longer the first thought. json.dumps(response.metadata) raises on the thread object; to_dict() is the documented serialisation and writes the thread through its own.

   python Copy

   import json
   from effgen import Agent, AgentConfig, thread_as_text
   
   agent = Agent(AgentConfig(
       model="Qwen/Qwen2.5-1.5B-Instruct",
       base_url="http://127.0.0.1:8000/v1",
   ))
   response = agent.run("What is 17 * 23?")
   
   print(thread_as_text(response.thread))     # the run, step by step
   json.dumps(response.to_dict())             # not json.dumps(response.metadata)

   AgentThread.to_text() is unchanged and still renders the flat transcript a 1.0.x reader would recognise. The same steps are on the command line as effgen run --show-thread, and in effgen run --json under metadata.thread.

2. Change 02

   A session's earlier turns render differently inside the prompt

   The === Previous Conversation Context === block with [Turn n] markers is gone; a one-string request now reads Earlier in this conversation: followed by User: / Assistant: lines. On a model whose adapter takes a conversation, a run whose tools travel as a request parameter sends the earlier turns as their own user and assistant messages and a caller's system_prompt as the system message, on every request of the run.

   Only code that matched on the old header text, or that reads the request a provider receives, is affected. The history itself is unchanged, and Session.last_thread() reads the steps directly.

3. Change 03

   AgentConfig(guardrails=...) accepts a plain list and rejects what is not a guardrail

   A list of guardrails no longer has to be wrapped, and a non-guardrail in the list raises TypeError at construction instead of failing later inside a run.

4. Change 04

   A 1.0.x checkpoint still resumes, and what the reconstruction drops is documented

   Checkpoint has a new thread field and still writes the flat transcript beside it, so a file 1.1.0 writes resumes on a build that only knows the transcript. A 1.0.x file has no steps, so Checkpoint.to_thread() rebuilds them and logs [compat] rebuilt a thread from a flat transcript. The rebuild cannot recover the provider's call id, a tool's arguments as values, which lines were the framework's own, or the run's frame.

5. Change 05

   agent.resume() continues an unfinished run instead of restarting the task

   The final checkpoint stores the run's steps where it used to store an empty transcript, so resuming picks up the conversation the run had and does not redo the turns the checkpoint already holds.

6. Change 06

   One agent loop, so stream() now behaves like run()

   The ReAct loop was written three times; there is one now. A blocking run is unchanged. A streamed run now sends the same prompt, the same tool definitions and the same sampling settings as run(), the loop guards fire on it as they do on a blocking run, and output guardrails are checked as run() checks them — a block raises out of the iterator.

   A streamed run that relied on the old behaviour — different sampling settings, a guard that never fired, an output guardrail that was never checked — now behaves as the blocking path always did.

7. Change 07

   A run is bounded by what it may send

   AgentConfig.context_budget ("auto" by default) and AgentConfig.compaction are new, and max_context_length is now the window override. When the conversation will not fit, the run gives up the oldest material first and never touches the frame, the task, the two most recent complete cycles or the answer. The budget is unbounded when the model declares no window. Session.keep_thread_history defaults to False, which keeps session files from growing.

   python Copy

   from effgen import AgentConfig
   
   config = AgentConfig(model="openai:gpt-5-nano")
   print(config.context_budget)        # auto — bounded by the model's own window
   print(AgentConfig(model="openai:gpt-5-nano", context_budget=8000).context_budget)
   print(AgentConfig(model="openai:gpt-5-nano", context_budget=None).context_budget)

   output

   auto
   8000
   None

   "auto" reproduces 1.0.x behaviour on any conversation that already fitted. Pass context_budget=None for the old unbounded behaviour, and Session(keep_thread_history=True) if you read the stored steps of earlier turns. A prompt larger than the model's window is now sent once rather than retried.

8. Change 08

   Orchestration results carry threads

   A run with no tools now reports metadata["thread"]. AgentResponse.sub_agent_threads(), WorkflowResult.thread / .threads / .node_thread() / .failed_nodes(), WorkflowNode.thread, TeamResponse.thread / .agent_threads(), WorkflowCheckpoint.threads / .tasks and SubAgentResult.thread are new and serialised into to_dict(). WorkflowDAG, TeamConfig and SubAgentManager take a projection that defaults to carrying nothing into a child run — what every pattern did before.

9. Change 09

   effgen run --json works on a run that used a tool, and its documents are scrubbed

   In 1.0.x, to_dict()["execution_tree"] carried ToolCall objects, so serialising any run that called a tool raised TypeError — taking effgen run --json, -o and --card with it. Those documents now serialise, and all three go through one scrubber, as does --show-thread.

   The terminal answer panel still prints the run's own words unredacted: a tool that puts a key in the answer puts it in the answer.

10. Change 10

    The debug trace carries steps

    DebugIteration gained thread_snapshot, and DebugIteration.to_dict() gained a thread key. The inspector renders every iteration from it, not only behind --step.

11. Change 11

    A run continuing a session sends its conversation as messages

    At the new default, prompt_protocol="auto", a run with tools that continues a session sends the session's earlier turns and its own steps as the messages they were, on a model that declares the message protocol and takes its tools as a request parameter — from its first request to its last, including the turn that asks for the answer after the guards stop offering tools. A run that continues nothing, and a run with no tools, sends the one string it always sent.

    python Copy

    from effgen import AgentConfig
    
    config = AgentConfig(model="openai:gpt-5-nano", prompt_protocol="flat")

    prompt_protocol="flat" keeps a session run's own steps in one string, as 1.0.x did. "messages" sends every run's conversation as turns, and ships opt-in.

One of them changes what success means for a run that stopped part way. Each carries the code that adapts to it.

1. Change 01

   A run that stops without an answer reports failure, and raises by default

   In 1.0.0 three paths returned success=True with the loop's internal state in .output: a computation tool that tripped the repeat guard, a computation tool that returned a result it had already returned, and a model that gave no final answer after its tools ran. 1.0.1 returns success=False, outcome="stopped" and a stop_reason naming the exit, and keeps what the model reached in .partial. Under the default raise_on_error=True the run raises RunStoppedError, which subclasses RuntimeError — what the iteration cap has always raised — and carries .response, .stop_reason and .partial.

   python Copy

   from effgen import Agent, AgentConfig, RunStoppedError
   
   agent = Agent(AgentConfig(model="openai:gpt-5-nano"))
   try:
       response = agent.run("What is 17 * 23?")
       print(response.outcome, response.stop_reason)
       print(response.text)
   except RunStoppedError as exc:
       print(exc.stop_reason)
       print(exc.partial.text if exc.partial else "nothing to report")

   Or pass raise_on_error=False and branch on .outcome, which is "answered", "stopped" or "failed". The text the model reached is in .partial.text, and still at metadata["partial_output"] byte for byte. The same outcome reaches the CLI, the run store, batch rows and their CSV, effgen code, EvalResult.stop_reason and the server's effgen envelope.

2. Change 02

   Citation markers are opt-in

   1.0.0 told the model to cite each passage inline as [1], [2], ... on every turn that followed a retrieval or search tool, whether or not you asked for citations. The markers pointed at nothing, and a question with a one-word answer came back with them attached. 1.0.1 adds them only when you ask, and a trailing marker on an answer you did not ask to be cited is removed.

   python Copy

   from effgen import Agent, AgentConfig
   
   agent = Agent(AgentConfig(model="openai:gpt-5-nano", cite_sources=True))
   
   # or for a single call
   agent.run("Summarise the retrieved notes.", cite_sources=True)

   The rag preset asks already. When you do ask, the retrieval results are numbered with the citation indexes, so [n] is citations[n - 1], across calls and for rows with a URL.

3. Change 03

   A streamed run sends the model's working before its answer

   Same task, same final answer, but the chunks a stream yields now start with the model's reasoning. Code that joins every chunk and shows the result shows the working first.

   python Copy

   events = list(agent.stream(task, include_events=True))
   answer = "".join(e.text for e in events if e.kind == "answer")

   Joining only the answer events reproduces response.output for a turn that answered.

4. Change 04

   A small local model writes more and reaches for tools more often

   Every tool-calling path now tells the model what its tools are for. On a small model running on the local Transformers engine that means longer completions, and a tool call on questions it used to answer directly. The answers stay the same; the token count and the wall time go up.

   python Copy

   from effgen import Agent, AgentConfig, load_model
   
   agent = Agent(AgentConfig(
       model=load_model("Qwen/Qwen2.5-1.5B-Instruct"),
       tools=tools,
       tool_use="sparing",   # a run that already has the answer gives it
   ))

   tool_contract="" states nothing about the tools at all, and tool_use="auto" requires nothing whatever the tools declare.

Everything else in 1.0.0 is additive. Each of the three carries the line that migrates it, and what that line printed when it was run.

1. Breaking 01

   Python 3.10 is no longer supported

   The floor is 3.11. tomllib, asyncio.timeout, datetime.UTC and the TimeoutError unification are all standard library from 3.11, and the package carried a hand-written fallback for each.

   bash Copy

   python --version   # 3.11, 3.12, 3.13 or 3.14

   output

   Python 3.11.15

   Nothing in the API changed.

2. Breaking 02

   AgentConfig.raise_on_error defaults to True

   A failed run raises its typed error instead of returning an AgentResponse with success=False and a plausible-looking string in .output — which a caller reading .output without checking .success never noticed.

   python Copy

   from effgen import Agent, AgentConfig
   
   agent = Agent(AgentConfig(model="openai:gpt-5-nano", raise_on_error=False))
   response = agent.run("Reply with the single word: ready")
   
   print(response.success, "|", response.text)

   output

   True | ready

   raise_on_error=False is also the documented setting for batch evaluation: with the flag off, a failed run's output is effGen's report of what stopped it, and the model's own text is in metadata["partial_output"].

3. Breaking 03

   An unreachable backend raises whatever that flag says

   A refused connection, an unresolvable host or a missing route is classified separately from a server that answered badly, and raises BackendUnreachableError. A task that ran and failed is a result you can inspect; a backend that was never reached is not, and returning one is how a whole batch completes against nothing and still looks healthy.

   python Copy

   from effgen import Agent, AgentConfig
   from effgen.models.errors import BackendUnreachableError
   
   agent = Agent(AgentConfig(
       model="openai:gpt-5-nano",
       base_url="http://127.0.0.1:9/v1",
       api_key="not-used",
       raise_on_error=False,
   ))
   
   try:
       agent.run("Anything.")
   except BackendUnreachableError as error:
       print(type(error).__name__)

   output

   BackendUnreachableError

   There is no opt-out, by design. Catch the error where you want to handle it.