loopgain 0.1.8__tar.gz → 0.2.0__tar.gz

{loopgain-0.1.8 → loopgain-0.2.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: loopgain
-Version: 0.1.8
+Version: 0.2.0
 Summary: Barkhausen stability monitor for AI agent loops. Real-time loop-gain (Aβ) monitoring with five named threshold bands, best-so-far rollback, and ETA prediction.
 Author-email: Dave Fitzsimmons <hello@loopgain.ai>
 License: Apache-2.0
 Project-URL: Homepage, https://loopgain.ai
 Project-URL: Repository, https://github.com/loopgain-ai/loopgain
 Project-URL: Issues, https://github.com/loopgain-ai/loopgain/issues
-Keywords: ai,agent,ai-agent,ai-agents,agentic,agentic-ai,llm,llm-agent,llm-orchestration,agent-orchestration,agent-loop,verify-revise,verify-revise-loop,gvr,generator-verifier-reviser,convergence,divergence-detection,infinite-loop,infinite-loop-detection,loop-detection,loop-stability,stability-monitor,early-stopping,max-iterations,barkhausen,barkhausen-criterion,control-theory,feedback-loop,feedback-loop-stability,loop-gain,rollback,best-so-far,langgraph,crewai,autogen,claude,anthropic,openai
+Keywords: ai,agent,ai-agent,ai-agents,agentic,agentic-ai,llm,llm-agent,llm-orchestration,agent-orchestration,agent-loop,verify-revise,verify-revise-loop,gvr,generator-verifier-reviser,convergence,divergence-detection,infinite-loop,infinite-loop-detection,loop-detection,loop-stability,stability-monitor,early-stopping,max-iterations,barkhausen,barkhausen-criterion,control-theory,feedback-loop,feedback-loop-stability,loop-gain,rollback,best-so-far,langgraph,crewai,autogen,langchain,openai-agents,openai-agents-sdk,claude-agent-sdk,claude,anthropic,openai
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -30,10 +30,21 @@ Provides-Extra: crewai
 Requires-Dist: crewai>=0.30; extra == "crewai"
 Provides-Extra: autogen
 Requires-Dist: autogen-agentchat>=0.4; extra == "autogen"
+Provides-Extra: langchain
+Requires-Dist: langchain>=1.0; extra == "langchain"
+Provides-Extra: openai-agents
+Requires-Dist: openai-agents>=0.1; extra == "openai-agents"
+Provides-Extra: claude-agent-sdk
+Requires-Dist: claude-agent-sdk>=0.2; extra == "claude-agent-sdk"
 Provides-Extra: all
 Requires-Dist: langgraph>=0.2; extra == "all"
 Requires-Dist: crewai>=0.30; extra == "all"
 Requires-Dist: autogen-agentchat>=0.4; extra == "all"
+Requires-Dist: langchain>=1.0; extra == "all"
+Requires-Dist: openai-agents>=0.1; extra == "all"
+Requires-Dist: claude-agent-sdk>=0.2; extra == "all"
+Provides-Extra: examples
+Requires-Dist: anthropic>=0.40.0; extra == "examples"
 Dynamic: license-file
 
 # LoopGain
@@ -49,7 +60,7 @@ Replace `max_iterations=5` with a real-time loop-gain (`Aβ`) monitor that knows
 
 **Home:** [loopgain.ai](https://loopgain.ai)
 
-Works for **any iterative AI workflow with a measurable error signal** — verify-revise loops, refinement passes, tool-use retry chains, RAG with self-correction, code-gen with linter feedback, multi-step reasoning loops. **Pre-built adapters for [LangGraph](#langgraph), [CrewAI](#crewai), and [AutoGen](#autogen-v04)**; drop-in via the raw API for **Claude Agent SDK** and any custom stack. Pure Python, no runtime dependencies.
+Works for **any iterative AI workflow with a measurable error signal** — verify-revise loops, refinement passes, tool-use retry chains, RAG with self-correction, code-gen with linter feedback, multi-step reasoning loops. **Pre-built adapters for [LangGraph](#langgraph), [CrewAI](#crewai), [AutoGen](#autogen-v04), [LangChain](#langchain), [OpenAI Agents SDK](#openai-agents-sdk), and [Claude Agent SDK](#claude-agent-sdk)**; drop-in via the raw API for any custom stack. Pure Python, no runtime dependencies.
 
 **Keywords:** AI agent loops · agentic AI · infinite loop detection · divergence detection · early stopping · convergence · agent orchestration · LLM stability · generator-verifier-reviser · feedback-loop control.
 
@@ -116,7 +127,7 @@ It classifies `Aβ_smooth` into five named bands:
 | `0.95 ≤ Aβ ≤ 1.05` | `OSCILLATING` | Break — return best-so-far |
 | `> 1.05` | `DIVERGING` | Abort — roll back to best-so-far |
 
-Plus a short-circuit: if observed error drops at or below `target_error`, the loop stops immediately with state `TARGET_MET`.
+Plus a short-circuit: if observed error drops at or below `target_error`, the loop stops immediately with state `TARGET_MET`. The default `target_error=0.0` short-circuits on exactly zero error — the natural completion signal for verifier-driven loops. Pass `target_error=None` to disable the short-circuit and rely on stability detection alone.
 
 The `±0.05` noise band around `Aβ=1` absorbs stochastic jitter from agent outputs without triggering false-positive aborts. The `0.85` `STALLING` boundary is an early warning — by the time `Aβ` crosses `1.0`, you've already wasted iterations.
 
@@ -156,7 +167,7 @@ This transforms divergence detection from "abort with garbage" into "abort with
 
 Construct the monitor.
 
-- `target_error` — Stop when an observed error drops at or below this. Default `0.0` means "never short-circuit on target met."
+- `target_error` — Stop when an observed error drops at or below this. Default `0.0` short-circuits on exactly zero error (the natural completion signal for verifier-driven loops). Pass `None` to disable the short-circuit entirely.
 - `max_iterations` — Hard safety cap. Default `None` (rely on stability detection). Recommended ~20–50 for production.
 - `thresholds` — Custom `ThresholdBands` if defaults don't fit your domain.
 - `smoothing_window` — EMA window for the smoothed Aβ. Default 3.
@@ -229,10 +240,13 @@ The hosted endpoint at `telemetry.loopgain.ai` is one acceptable destination. Th
 Thin wrappers under `loopgain.integrations` drive each major agent framework's iteration with a `LoopGain` monitor and auto-stamp `framework="<name>"` on telemetry. The frameworks themselves are **optional dependencies** — install the extra you need:
 
 ```bash
-pip install 'loopgain[langgraph]'   # LangGraph
-pip install 'loopgain[crewai]'      # CrewAI
-pip install 'loopgain[autogen]'     # AutoGen v0.4+
-pip install 'loopgain[all]'         # all three
+pip install 'loopgain[langgraph]'          # LangGraph
+pip install 'loopgain[crewai]'             # CrewAI
+pip install 'loopgain[autogen]'            # AutoGen v0.4+
+pip install 'loopgain[langchain]'          # LangChain (create_agent / AgentExecutor)
+pip install 'loopgain[openai-agents]'      # OpenAI Agents SDK
+pip install 'loopgain[claude-agent-sdk]'   # Anthropic Claude Agent SDK
+pip install 'loopgain[all]'                # all six
 ```
 
 All adapters take a `LoopGain` instance plus an `error_fn` you provide — the framework doesn't know what your error signal is, so the adapter doesn't either. `error_fn` returns a non-negative number (or `None` to skip an iteration).
@@ -319,15 +333,120 @@ lg.send_telemetry(
 
 Pass a `cancellation_token` to `adapter.run(...)` and the adapter will cancel it when LoopGain reaches a terminal state (target met, oscillation, divergence). The legacy v0.2 `ConversableAgent.initiate_chat` API is **not** supported — use the v0.4 event-driven runtime.
 
+### LangChain
+
+Duck-types against any LangChain agent that exposes `.stream(input, **kwargs)` / `.astream(input, **kwargs)` — both the current `langchain.agents.create_agent()` (v1+) and the legacy `AgentExecutor`. The adapter forwards `**stream_kwargs` verbatim, so the chunk shape your `error_fn` sees is the one your agent emits.
+
+```python
+from langchain.agents import create_agent
+from loopgain import LoopGain
+from loopgain.integrations import LangChainAdapter
+
+agent = create_agent(model="gpt-5-nano", tools=[get_weather])
+lg = LoopGain(target_error=0.0, max_iterations=20)
+
+def error_fn(chunk):
+    if chunk.get("type") != "updates":
+        return None
+    # Count unresolved tool calls; drops to 0 once the agent stops calling tools.
+    return sum(
+        1 for _, update in chunk["data"].items()
+        if getattr(update.get("messages", [None])[-1], "tool_calls", None)
+    )
+
+adapter = LangChainAdapter(lg=lg, error_fn=error_fn)
+final = adapter.run(
+    agent,
+    {"messages": [{"role": "user", "content": "What's the weather?"}]},
+    stream_mode="updates",
+    version="v2",
+)
+
+lg.send_telemetry(
+    endpoint=...,
+    token=...,
+    framework=adapter.framework_name,        # "langchain"
+)
+```
+
+For legacy `AgentExecutor`: just drop the `stream_mode` / `version` kwargs; each yielded chunk is an `AddableDict` per step (parse `intermediate_steps` or the terminal `output` key in your `error_fn`).
+
+### OpenAI Agents SDK
+
+Wraps `Runner.run_streamed(agent, input).stream_events()`. The SDK is async-first; the adapter mirrors that. A `run_sync` helper wraps the async path with `asyncio.run` for synchronous callers.
+
+```python
+from agents import Agent, function_tool
+from loopgain import LoopGain
+from loopgain.integrations import OpenAIAgentsAdapter
+
+agent = Agent(name="Reviser", instructions="...", tools=[...])
+
+lg = LoopGain(target_error=0.0, max_iterations=20)
+
+def error_fn(event):
+    # Default observes only run_item_stream_event; pull the verifier's
+    # reported failure count off tool outputs.
+    if event.item.type == "tool_call_output_item":
+        return float(event.item.output.get("failures", 0))
+    return None
+
+adapter = OpenAIAgentsAdapter(lg=lg, error_fn=error_fn)
+result = await adapter.run(agent, input="Fix the bug.")
+print(result.final_output)
+
+lg.send_telemetry(
+    endpoint=...,
+    token=...,
+    framework=adapter.framework_name,        # "openai-agents"
+)
+```
+
+By default the adapter only forwards `run_item_stream_event` to `error_fn` — pass `observe_event_types=None` to see every event (including raw token deltas and agent-handoff notifications). When LoopGain reaches a terminal state, the adapter best-effort calls `.cancel()` on the underlying `RunResultStreaming`.
+
+### Claude Agent SDK
+
+Wraps Anthropic's `claude_agent_sdk.query(prompt=..., options=...)` async iterator. By default observes only `AssistantMessage` (skips `UserMessage` / `SystemMessage` / `ResultMessage`); override with `observe_message_types=None` or a custom tuple.
+
+```python
+from claude_agent_sdk import ClaudeAgentOptions, TextBlock
+from loopgain import LoopGain
+from loopgain.integrations import ClaudeAgentSDKAdapter
+
+def error_fn(message):
+    # Count `FAIL:` markers a self-verifying persona emits.
+    for block in getattr(message, "content", []):
+        if isinstance(block, TextBlock):
+            return float(block.text.count("FAIL:"))
+    return None
+
+lg = LoopGain(target_error=0.0, max_iterations=20)
+adapter = ClaudeAgentSDKAdapter(lg=lg, error_fn=error_fn)
+
+options = ClaudeAgentOptions(system_prompt="Self-verify each draft.")
+result = await adapter.run(
+    prompt="Write a haiku about feedback loops.",
+    options=options,
+)
+
+lg.send_telemetry(
+    endpoint=...,
+    token=...,
+    framework=adapter.framework_name,        # "claude-agent-sdk"
+)
+```
+
+For the bidirectional `ClaudeSDKClient` use case, pass `message_iterator=client.receive_messages()` instead of `prompt=...`.
+
 ### Custom integrations
 
-For frameworks without an adapter, the raw `LoopGain.observe()` API works against any iterable. The adapters are 100-200 lines each — copy one of `loopgain/integrations/{langgraph,crewai,autogen}.py` as a starting point.
+For frameworks without an adapter, the raw `LoopGain.observe()` API works against any iterable. The adapters are 100-200 lines each — copy one of `loopgain/integrations/{langgraph,crewai,autogen,langchain,openai_agents,claude_agent_sdk}.py` as a starting point.
 
 ---
 
 ## Status
 
-**Initial public release.** Core library shipped (current version: see the PyPI badge at the top). Framework adapters (LangGraph, CrewAI, AutoGen) are installable as optional extras. The cloud-aggregator [telemetry receiver](https://github.com/loopgain-ai/telemetry-receiver) and [dashboard](https://github.com/loopgain-ai/dashboard) are live as separate open-source repos. The math and the API surface are stable.
+**Initial public release.** Core library shipped (current version: see the PyPI badge at the top). Framework adapters (LangGraph, CrewAI, AutoGen, LangChain, OpenAI Agents SDK, Claude Agent SDK) are installable as optional extras. The cloud-aggregator [telemetry receiver](https://github.com/loopgain-ai/telemetry-receiver) and [dashboard](https://github.com/loopgain-ai/dashboard) are live as separate open-source repos. The math and the API surface are stable.
 
 This is alpha software. The API may break before 1.0 if production usage surfaces design issues; pin the version.
 

{loopgain-0.1.8 → loopgain-0.2.0}/README.md

@@ -11,7 +11,7 @@ Replace `max_iterations=5` with a real-time loop-gain (`Aβ`) monitor that knows
 
 **Home:** [loopgain.ai](https://loopgain.ai)
 
-Works for **any iterative AI workflow with a measurable error signal** — verify-revise loops, refinement passes, tool-use retry chains, RAG with self-correction, code-gen with linter feedback, multi-step reasoning loops. **Pre-built adapters for [LangGraph](#langgraph), [CrewAI](#crewai), and [AutoGen](#autogen-v04)**; drop-in via the raw API for **Claude Agent SDK** and any custom stack. Pure Python, no runtime dependencies.
+Works for **any iterative AI workflow with a measurable error signal** — verify-revise loops, refinement passes, tool-use retry chains, RAG with self-correction, code-gen with linter feedback, multi-step reasoning loops. **Pre-built adapters for [LangGraph](#langgraph), [CrewAI](#crewai), [AutoGen](#autogen-v04), [LangChain](#langchain), [OpenAI Agents SDK](#openai-agents-sdk), and [Claude Agent SDK](#claude-agent-sdk)**; drop-in via the raw API for any custom stack. Pure Python, no runtime dependencies.
 
 **Keywords:** AI agent loops · agentic AI · infinite loop detection · divergence detection · early stopping · convergence · agent orchestration · LLM stability · generator-verifier-reviser · feedback-loop control.
 
@@ -78,7 +78,7 @@ It classifies `Aβ_smooth` into five named bands:
 | `0.95 ≤ Aβ ≤ 1.05` | `OSCILLATING` | Break — return best-so-far |
 | `> 1.05` | `DIVERGING` | Abort — roll back to best-so-far |
 
-Plus a short-circuit: if observed error drops at or below `target_error`, the loop stops immediately with state `TARGET_MET`.
+Plus a short-circuit: if observed error drops at or below `target_error`, the loop stops immediately with state `TARGET_MET`. The default `target_error=0.0` short-circuits on exactly zero error — the natural completion signal for verifier-driven loops. Pass `target_error=None` to disable the short-circuit and rely on stability detection alone.
 
 The `±0.05` noise band around `Aβ=1` absorbs stochastic jitter from agent outputs without triggering false-positive aborts. The `0.85` `STALLING` boundary is an early warning — by the time `Aβ` crosses `1.0`, you've already wasted iterations.
 
@@ -118,7 +118,7 @@ This transforms divergence detection from "abort with garbage" into "abort with
 
 Construct the monitor.
 
-- `target_error` — Stop when an observed error drops at or below this. Default `0.0` means "never short-circuit on target met."
+- `target_error` — Stop when an observed error drops at or below this. Default `0.0` short-circuits on exactly zero error (the natural completion signal for verifier-driven loops). Pass `None` to disable the short-circuit entirely.
 - `max_iterations` — Hard safety cap. Default `None` (rely on stability detection). Recommended ~20–50 for production.
 - `thresholds` — Custom `ThresholdBands` if defaults don't fit your domain.
 - `smoothing_window` — EMA window for the smoothed Aβ. Default 3.
@@ -191,10 +191,13 @@ The hosted endpoint at `telemetry.loopgain.ai` is one acceptable destination. Th
 Thin wrappers under `loopgain.integrations` drive each major agent framework's iteration with a `LoopGain` monitor and auto-stamp `framework="<name>"` on telemetry. The frameworks themselves are **optional dependencies** — install the extra you need:
 
 ```bash
-pip install 'loopgain[langgraph]'   # LangGraph
-pip install 'loopgain[crewai]'      # CrewAI
-pip install 'loopgain[autogen]'     # AutoGen v0.4+
-pip install 'loopgain[all]'         # all three
+pip install 'loopgain[langgraph]'          # LangGraph
+pip install 'loopgain[crewai]'             # CrewAI
+pip install 'loopgain[autogen]'            # AutoGen v0.4+
+pip install 'loopgain[langchain]'          # LangChain (create_agent / AgentExecutor)
+pip install 'loopgain[openai-agents]'      # OpenAI Agents SDK
+pip install 'loopgain[claude-agent-sdk]'   # Anthropic Claude Agent SDK
+pip install 'loopgain[all]'                # all six
 ```
 
 All adapters take a `LoopGain` instance plus an `error_fn` you provide — the framework doesn't know what your error signal is, so the adapter doesn't either. `error_fn` returns a non-negative number (or `None` to skip an iteration).
@@ -281,15 +284,120 @@ lg.send_telemetry(
 
 Pass a `cancellation_token` to `adapter.run(...)` and the adapter will cancel it when LoopGain reaches a terminal state (target met, oscillation, divergence). The legacy v0.2 `ConversableAgent.initiate_chat` API is **not** supported — use the v0.4 event-driven runtime.
 
+### LangChain
+
+Duck-types against any LangChain agent that exposes `.stream(input, **kwargs)` / `.astream(input, **kwargs)` — both the current `langchain.agents.create_agent()` (v1+) and the legacy `AgentExecutor`. The adapter forwards `**stream_kwargs` verbatim, so the chunk shape your `error_fn` sees is the one your agent emits.
+
+```python
+from langchain.agents import create_agent
+from loopgain import LoopGain
+from loopgain.integrations import LangChainAdapter
+
+agent = create_agent(model="gpt-5-nano", tools=[get_weather])
+lg = LoopGain(target_error=0.0, max_iterations=20)
+
+def error_fn(chunk):
+    if chunk.get("type") != "updates":
+        return None
+    # Count unresolved tool calls; drops to 0 once the agent stops calling tools.
+    return sum(
+        1 for _, update in chunk["data"].items()
+        if getattr(update.get("messages", [None])[-1], "tool_calls", None)
+    )
+
+adapter = LangChainAdapter(lg=lg, error_fn=error_fn)
+final = adapter.run(
+    agent,
+    {"messages": [{"role": "user", "content": "What's the weather?"}]},
+    stream_mode="updates",
+    version="v2",
+)
+
+lg.send_telemetry(
+    endpoint=...,
+    token=...,
+    framework=adapter.framework_name,        # "langchain"
+)
+```
+
+For legacy `AgentExecutor`: just drop the `stream_mode` / `version` kwargs; each yielded chunk is an `AddableDict` per step (parse `intermediate_steps` or the terminal `output` key in your `error_fn`).
+
+### OpenAI Agents SDK
+
+Wraps `Runner.run_streamed(agent, input).stream_events()`. The SDK is async-first; the adapter mirrors that. A `run_sync` helper wraps the async path with `asyncio.run` for synchronous callers.
+
+```python
+from agents import Agent, function_tool
+from loopgain import LoopGain
+from loopgain.integrations import OpenAIAgentsAdapter
+
+agent = Agent(name="Reviser", instructions="...", tools=[...])
+
+lg = LoopGain(target_error=0.0, max_iterations=20)
+
+def error_fn(event):
+    # Default observes only run_item_stream_event; pull the verifier's
+    # reported failure count off tool outputs.
+    if event.item.type == "tool_call_output_item":
+        return float(event.item.output.get("failures", 0))
+    return None
+
+adapter = OpenAIAgentsAdapter(lg=lg, error_fn=error_fn)
+result = await adapter.run(agent, input="Fix the bug.")
+print(result.final_output)
+
+lg.send_telemetry(
+    endpoint=...,
+    token=...,
+    framework=adapter.framework_name,        # "openai-agents"
+)
+```
+
+By default the adapter only forwards `run_item_stream_event` to `error_fn` — pass `observe_event_types=None` to see every event (including raw token deltas and agent-handoff notifications). When LoopGain reaches a terminal state, the adapter best-effort calls `.cancel()` on the underlying `RunResultStreaming`.
+
+### Claude Agent SDK
+
+Wraps Anthropic's `claude_agent_sdk.query(prompt=..., options=...)` async iterator. By default observes only `AssistantMessage` (skips `UserMessage` / `SystemMessage` / `ResultMessage`); override with `observe_message_types=None` or a custom tuple.
+
+```python
+from claude_agent_sdk import ClaudeAgentOptions, TextBlock
+from loopgain import LoopGain
+from loopgain.integrations import ClaudeAgentSDKAdapter
+
+def error_fn(message):
+    # Count `FAIL:` markers a self-verifying persona emits.
+    for block in getattr(message, "content", []):
+        if isinstance(block, TextBlock):
+            return float(block.text.count("FAIL:"))
+    return None
+
+lg = LoopGain(target_error=0.0, max_iterations=20)
+adapter = ClaudeAgentSDKAdapter(lg=lg, error_fn=error_fn)
+
+options = ClaudeAgentOptions(system_prompt="Self-verify each draft.")
+result = await adapter.run(
+    prompt="Write a haiku about feedback loops.",
+    options=options,
+)
+
+lg.send_telemetry(
+    endpoint=...,
+    token=...,
+    framework=adapter.framework_name,        # "claude-agent-sdk"
+)
+```
+
+For the bidirectional `ClaudeSDKClient` use case, pass `message_iterator=client.receive_messages()` instead of `prompt=...`.
+
 ### Custom integrations
 
-For frameworks without an adapter, the raw `LoopGain.observe()` API works against any iterable. The adapters are 100-200 lines each — copy one of `loopgain/integrations/{langgraph,crewai,autogen}.py` as a starting point.
+For frameworks without an adapter, the raw `LoopGain.observe()` API works against any iterable. The adapters are 100-200 lines each — copy one of `loopgain/integrations/{langgraph,crewai,autogen,langchain,openai_agents,claude_agent_sdk}.py` as a starting point.
 
 ---
 
 ## Status
 
-**Initial public release.** Core library shipped (current version: see the PyPI badge at the top). Framework adapters (LangGraph, CrewAI, AutoGen) are installable as optional extras. The cloud-aggregator [telemetry receiver](https://github.com/loopgain-ai/telemetry-receiver) and [dashboard](https://github.com/loopgain-ai/dashboard) are live as separate open-source repos. The math and the API surface are stable.
+**Initial public release.** Core library shipped (current version: see the PyPI badge at the top). Framework adapters (LangGraph, CrewAI, AutoGen, LangChain, OpenAI Agents SDK, Claude Agent SDK) are installable as optional extras. The cloud-aggregator [telemetry receiver](https://github.com/loopgain-ai/telemetry-receiver) and [dashboard](https://github.com/loopgain-ai/dashboard) are live as separate open-source repos. The math and the API surface are stable.
 
 This is alpha software. The API may break before 1.0 if production usage surfaces design issues; pin the version.
 

{loopgain-0.1.8 → loopgain-0.2.0}/loopgain/_version.py

@@ -6,4 +6,4 @@ Both ``loopgain/__init__.py`` and ``loopgain/telemetry.py`` import
 Update this file (and ``pyproject.toml``) for each release.
 """
 
-__version__ = "0.1.8"
+__version__ = "0.2.0"

{loopgain-0.1.8 → loopgain-0.2.0}/loopgain/core.py

@@ -113,8 +113,9 @@ class LoopGainResult:
     """First non-None ``eta`` snapshot captured during the loop —
     the predicted iterations-remaining at the moment the prediction
     became computable. ``None`` if no prediction was ever made
-    (e.g., ``target_error == 0``, loop never converged toward target,
-    or the loop terminated before two observations)."""
+    (e.g., ``target_error`` is ``None`` or ``0`` so the prediction
+    formula is undefined, loop never converged toward target, or the
+    loop terminated before two observations)."""
 
     first_eta_at_iteration: Optional[int] = None
     """Iteration count when ``first_eta_prediction`` was captured.
@@ -149,7 +150,11 @@ class LoopGain:
 
     Args:
         target_error: Stop when an observed error drops at or below this.
-            Default ``0.0`` means "never stop early on target met."
+            Default ``0.0`` short-circuits on exactly zero error — the
+            natural completion signal for most verifiers (no failing
+            tests, no validation errors, etc.). Pass ``None`` to disable
+            the short-circuit entirely and rely only on stability
+            detection and ``max_iterations``.
         max_iterations: Hard safety cap. Default ``None`` (rely on
             stability detection). Recommended ~20-50 for production.
         thresholds: Custom ``ThresholdBands``. Default is the canonical
@@ -161,7 +166,7 @@ class LoopGain:
 
     def __init__(
         self,
-        target_error: float = 0.0,
+        target_error: Optional[float] = 0.0,
         max_iterations: Optional[int] = None,
         thresholds: Optional[ThresholdBands] = None,
         smoothing_window: int = 3,
@@ -169,12 +174,14 @@ class LoopGain:
     ) -> None:
         if smoothing_window < 1:
             raise ValueError("smoothing_window must be >= 1")
-        if target_error < 0:
-            raise ValueError("target_error must be non-negative")
+        if target_error is not None and target_error < 0:
+            raise ValueError("target_error must be non-negative or None")
         if max_iterations is not None and max_iterations < 1:
             raise ValueError("max_iterations must be >= 1 or None")
 
-        self.target_error = float(target_error)
+        self.target_error: Optional[float] = (
+            float(target_error) if target_error is not None else None
+        )
         self.max_iterations = max_iterations
         self.thresholds = thresholds or ThresholdBands()
         self.smoothing_window = smoothing_window
@@ -217,7 +224,9 @@ class LoopGain:
         self._outputs.append(output)
 
         # TARGET_MET short-circuit takes precedence over band classification.
-        if magnitude <= self.target_error and self.target_error > 0:
+        # target_error=None disables the short-circuit entirely; any non-None
+        # value (including 0.0) fires TARGET_MET when magnitude <= target.
+        if self.target_error is not None and magnitude <= self.target_error:
             self._state = TARGET_MET
             self._terminal = True
             return self._state
@@ -289,12 +298,13 @@ class LoopGain:
             n_remaining = log(E_target / E_current) / log(Aβ_smooth)
 
         Returns ``None`` when the prediction isn't well-defined:
-        no Aβ yet, ``target_error`` is zero, target already met, or
-        ``Aβ_smooth >= 1`` (non-converging gain).
+        no Aβ yet, ``target_error`` is ``None`` (no target to predict
+        against) or ``0`` (the formula has a log-of-zero singularity),
+        target already met, or ``Aβ_smooth >= 1`` (non-converging gain).
         """
         if not self._smoothed_history or not self._error_history:
             return None
-        if self.target_error <= 0:
+        if self.target_error is None or self.target_error <= 0:
             return None
         e_current = self._error_history[-1]
         if e_current <= self.target_error:

{loopgain-0.1.8 → loopgain-0.2.0}/loopgain/integrations/__init__.py

@@ -5,22 +5,26 @@ calls ``LoopGain.observe()`` on each step with an error magnitude derived
 from a user-provided ``error_fn``, and (optionally) sends telemetry on
 completion with ``framework="<name>"`` auto-stamped.
 
-Adapters are isolated submodules so the host frameworks (langgraph, crewai,
-autogen) remain *optional* dependencies. Importing this package does not
-import any framework — each adapter only imports its framework when its
-class is instantiated, and surfaces a clear ``ImportError`` if missing.
+Adapters are isolated submodules so the host frameworks (langgraph,
+crewai, autogen, langchain, openai-agents, claude-agent-sdk) remain
+*optional* dependencies. Importing this package does not import any
+framework — each adapter only imports its framework when its class is
+instantiated, and surfaces a clear ``ImportError`` if missing.
 
 Install adapter extras::
 
-    pip install 'loopgain[langgraph]'   # LangGraph
-    pip install 'loopgain[crewai]'      # CrewAI
-    pip install 'loopgain[autogen]'     # AutoGen v0.4+
-    pip install 'loopgain[all]'         # all of the above
+    pip install 'loopgain[langgraph]'          # LangGraph
+    pip install 'loopgain[crewai]'             # CrewAI
+    pip install 'loopgain[autogen]'            # AutoGen v0.4+
+    pip install 'loopgain[langchain]'          # LangChain (create_agent or AgentExecutor)
+    pip install 'loopgain[openai-agents]'      # OpenAI Agents SDK
+    pip install 'loopgain[claude-agent-sdk]'   # Anthropic Claude Agent SDK
+    pip install 'loopgain[all]'                # all of the above
 
 Common pattern::
 
     from loopgain import LoopGain
-    from loopgain.integrations import LangGraphAdapter   # or CrewAIAdapter, AutoGenAdapter
+    from loopgain.integrations import LangGraphAdapter   # or any other adapter
 
     lg = LoopGain(target_error=0.1, max_iterations=20)
     adapter = LangGraphAdapter(
@@ -40,13 +44,16 @@ Common pattern::
 
 from __future__ import annotations
 
-# Adapters are imported lazily so importing this package does NOT pull in
-# langgraph / crewai / autogen. Each name resolves on first attribute access
-# and surfaces a clear ImportError if its host framework isn't installed.
+# Adapters are imported lazily so importing this package does NOT pull
+# in any framework. Each name resolves on first attribute access and
+# surfaces a clear ImportError if its host framework isn't installed.
 __all__ = [
     "LangGraphAdapter",
     "CrewAIAdapter",
     "AutoGenAdapter",
+    "LangChainAdapter",
+    "OpenAIAgentsAdapter",
+    "ClaudeAgentSDKAdapter",
 ]
 
 
@@ -63,4 +70,16 @@ def __getattr__(name: str):
         from loopgain.integrations.autogen import AutoGenAdapter
 
         return AutoGenAdapter
+    if name == "LangChainAdapter":
+        from loopgain.integrations.langchain import LangChainAdapter
+
+        return LangChainAdapter
+    if name == "OpenAIAgentsAdapter":
+        from loopgain.integrations.openai_agents import OpenAIAgentsAdapter
+
+        return OpenAIAgentsAdapter
+    if name == "ClaudeAgentSDKAdapter":
+        from loopgain.integrations.claude_agent_sdk import ClaudeAgentSDKAdapter
+
+        return ClaudeAgentSDKAdapter
     raise AttributeError(f"module 'loopgain.integrations' has no attribute {name!r}")