react-agent-harness 0.1.0__tar.gz → 0.3.0__tar.gz

{react_agent_harness-0.1.0/react_agent_harness.egg-info → react_agent_harness-0.3.0}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: react-agent-harness
-Version: 0.1.0
+Version: 0.3.0
 Summary: Multi-agent LLM orchestration: hybrid DAG planning, two-tier memory, streaming
 Requires-Python: >=3.10
 License-File: LICENSE
+Requires-Dist: prompt_toolkit>=3.0
 Provides-Extra: lance
 Requires-Dist: lancedb>=0.6; extra == "lance"
 Requires-Dist: pyarrow>=14; extra == "lance"

{react_agent_harness-0.1.0 → react_agent_harness-0.3.0}/README.md

@@ -38,6 +38,7 @@ harness/events.py           BusEvent + EventType — canonical event vocabulary
 harness/llm/openai.py       OpenAILLM — OpenAI adapter with usage + cost tracking
 harness/annotation.py       Annotation store + AnnotationHook — RLHF trajectory capture
 harness/hitl.py             HITL approval gate — interactive CLI, session-allow list
+harness/steering.py         Async steering — agent.steer(text), StdinRouter pub/sub, FileSteer, factory helpers
 harness/checkpoint.py       CheckpointStore + _ResumeHint + maybe_resume_key — pluggable run-state persistence (file + Redis); auto-resume built into dispatch_stream / run_stream
 harness/otel.py             OTELHook — OpenTelemetry span exporter (opt-in)
 harness/executor_bridge.py  ExecutorBridge + ExecutorTool — controlled subprocess launcher with optional Docker sandboxing
@@ -73,6 +74,7 @@ explicit control.
 | `examples/executor_bridge_demo.py` | `ExecutorBridge` backends side-by-side: allowlist, env scrubbing, Docker network/fs isolation, timeout, positional-arg tools. | `ah-executor` and/or Docker |
 | `examples/durable_memory_demo.py` | Redis (semantic) + LanceDB (episodic) memory persistence across two related goals. | `OPENAI_API_KEY`, `[openai,redis,lance]`, Redis reachable |
 | `examples/mcp_demo.py` | Connects to an MCP filesystem server and gives the agent its tools. | `OPENAI_API_KEY`, `[openai,mcp]`, `npx` |
+| `examples/subscription_auth_demo.py` | Runs an agent through subscription-backed providers: direct `openai-codex` OAuth or direct `claude-code` OAuth. | `agent-harness login openai-codex` or `agent-harness login claude-code` |
 
 ## Adding a new domain (3 steps)
 
@@ -108,6 +110,102 @@ llm = OpenAILLM(model="gpt-4o-mini")                # reads OPENAI_API_KEY from
 runtime = AgentRuntime(..., llm=llm)
 ```
 
+Credential-backed adapters can also plug into the same contract. This is the
+shape used for provider-specific subscription or OAuth flows without teaching
+agents about auth:
+
+```bash
+agent-harness login openai-codex
+agent-harness auth status openai-codex
+agent-harness login claude-code
+agent-harness auth status claude-code
+```
+
+> **⚠️ Subscription adapters are experimental — use the metered API in production.**
+>
+> `OpenAICodexLLM` and `ClaudeCodeLLM` bridge **ChatGPT / Claude
+> subscription OAuth credentials** into the harness by talking to
+> internal CLI endpoints with CLI-shaped User-Agent and billing headers.
+> This route:
+>
+> - **May violate OpenAI's and Anthropic's Terms of Service.** Both
+>   providers prohibit using subscription accounts (ChatGPT Plus/Pro,
+>   Claude Pro/Max) for arbitrary programmatic access — subscriptions
+>   price for the official CLI's intended use only.
+> - **May result in account suspension** if abuse detection classifies
+>   harness traffic as misuse.
+> - **Depends on undocumented internal endpoints**
+>   (`/backend-api/codex/responses`, the Anthropic Messages API with
+>   `claude-code-*` beta flags) that providers can change or revoke at
+>   any time.
+>
+> **Use these adapters only for personal research on accounts you own.**
+> Do not use them to serve other users. For anything else, prefer the
+> metered API path:
+>
+> - `OpenAILLM` with `OPENAI_API_KEY` (optionally routed through a
+>   gateway like LiteLLM/Helicone for cost headers).
+> - The standard Anthropic Messages API with an Anthropic API key.
+
+Direct `openai-codex` OAuth follows the Codex/Pi-style ChatGPT
+subscription route rather than the stable OpenAI Platform API. The
+Codex OAuth client id can be overridden with
+`AGENT_HARNESS_OPENAI_CODEX_CLIENT_ID`.
+
+```python
+from harness.llm.openai_codex import OpenAICodexLLM
+
+llm = OpenAICodexLLM(
+    model="gpt-5.5",
+    auth_file="~/.agent-harness/auth/auth.json",  # Pi-shaped openai-codex OAuth entry
+)
+runtime = AgentRuntime(..., llm=llm)
+```
+
+`OpenAICodexLLM` calls the Codex backend directly
+(`https://chatgpt.com/backend-api/codex/responses`) with OAuth credentials.
+The stable fallback remains `OpenAILLM` with `OPENAI_API_KEY`.
+
+For Claude Code-style setups, use `ClaudeCodeLLM` with Claude Pro/Max OAuth
+credentials stored in the same auth file. It calls the Anthropic Messages API
+directly with Claude-Code-compatible OAuth headers:
+
+```bash
+agent-harness login claude-code
+python examples/subscription_auth_demo.py claude-code
+```
+
+```python
+from harness.llm.claude_code import ClaudeCodeLLM
+
+llm = ClaudeCodeLLM(
+    model="claude-sonnet-4-6",
+    auth_file="~/.agent-harness/auth/auth.json",
+)
+```
+
+`ClaudeCodeLLM` reads a `claude-code` OAuth entry, refreshes it automatically
+when expired, and retries once after `401`/`403`. This mirrors Pi's Claude
+Pro/Max extension approach rather than shelling out to the Claude CLI. The
+default model is the current canonical Sonnet release ID, `claude-sonnet-4-6`;
+set `CLAUDE_CODE_MODEL` or pass `model="claude-opus-4-7"` to choose another
+model.
+
+Both adapters stream incrementally — `stream_complete()` yields each
+SSE delta token as it arrives, and `complete()` consumes the same
+stream and returns the concatenated text once finished. Cost / token
+usage is captured from the final stream event into `last_usage`.
+
+The Claude billing header's `cc_version` is read from
+`CLAUDE_CODE_VERSION` (env) or from `claude --version` if the CLI is
+installed; falls back to `unknown` otherwise. Pinning a specific
+version with `CLAUDE_CODE_VERSION=2.1.150` is recommended if you want
+stable behavior across CLI upgrades.
+
+Do not copy browser/app refresh tokens into repo files. Store OAuth auth files
+under `~/.agent-harness/auth` or reuse an existing Pi auth file with private
+file permissions (`0600`).
+
 To use Anthropic / Gemini / Ollama / a local SGLang or vLLM server / anything
 else — write a 30-line adapter implementing those two methods. See
 `harness/llm/openai.py` for the reference shape; the harness never imports a
@@ -720,3 +818,94 @@ When the human types a correction instead of y/n:
 
 The `annotation_store` and `checkpoint_store` are independent — both can be
 wired simultaneously for RLHF data collection with HITL review.
+
+## Async steering
+
+HITL is synchronous — it only fires when a gated tool is about to run. For
+out-of-band course-correction (HTTP handler, supervisor agent, file watcher,
+or a human typing in the terminal), each `BaseAgent` exposes a
+non-blocking `steer(text)` method. Items are drained at the **top of each
+ReAct iteration**, before the per-step checkpoint write and before the
+next think, then appended to `WorkingMemory` as a `Human guidance: <text>`
+user message. The LLM sees them on the next think and adjusts. One
+`HUMAN_GUIDANCE` `BusEvent` fires per drained item.
+
+Why a queue instead of writing straight to `WorkingMemory`: `steer()` is
+synchronous and callable from any coroutine; `WorkingMemory.append` is
+async (eviction can call the LLM). The queue is the producer/consumer
+boundary, enforces step-boundary delivery, and keeps WM single-writer.
+
+### Programmatic API (always available)
+
+```python
+agent.steer("skip the legal database, use academic sources only")
+```
+
+Fires immediately; the agent picks it up at the next step boundary.
+Worst-case latency = remaining tool time + next-think time.
+
+### Sources via factory (so orchestrated agents are reachable)
+
+`BaseAgent` and `AgentRuntime` both accept `steering_source_factory` — a
+callable `(agent) -> async ctx mgr`. The agent enters the source on
+`run_stream`, exits on completion. No live-agent registry; agents the
+runtime constructs internally still get steering.
+
+Two built-in factories:
+
+```python
+from harness.steering import file_steering_factory, stdin_steering_factory
+
+# 1. File-based — one file per agent, polled for appends (no shared resource)
+runtime = AgentRuntime(
+    ...,
+    steering_source_factory=file_steering_factory(
+        "/tmp/ah-{run_id}-{agent_id}.steer"
+    ),
+)
+# Steer from any other terminal:
+#   echo "wrap up and synthesise" >> /tmp/ah-<run_id>-researcher.steer
+
+# 2. Stdin-based — single shared StdinRouter with prefix routing
+runtime = AgentRuntime(
+    ...,
+    steering_source_factory=stdin_steering_factory(),
+)
+# At the terminal:
+#   researcher: skip the legal db, focus on academic
+#   writer:     keep the report under 500 words
+#   *:          stop after this step
+```
+
+Single-agent stdin runs accept lines with no prefix. Multi-agent runs
+require `agent_id: text` (or `*: text` for broadcast); unknown or
+unprefixed lines print a stderr hint and are discarded.
+
+The stdin factory's underlying `StdinRouter` is started/stopped
+automatically — the runtime detects the factory's async-context-manager
+shape and wraps `dispatch_stream` / `run_stream` / `run_routed_stream`
+around it. Ref-counted so nested calls (`dispatch_stream → run_stream`)
+don't double-start the router.
+
+### HITL coordination
+
+When a `StdinRouter` is active, HITL calls `router.claim_next_line()`
+**before** printing its approval banner — the next stdin line resolves
+HITL's pending Future and bypasses pub/sub. After resolution, subsequent
+lines route to steering subscribers normally. When no router is active,
+HITL falls back to a standalone `prompt_toolkit` session, ensuring consistent
+key-bindings (like Enter-submits and Alt-Enter/Ctrl-J-newline) across both paths.
+
+### Constraints
+
+- Steering arrives **between steps**, never mid-tool, never mid-think.
+  Tools that are already running complete; the LLM stream that's
+  already producing completes; guidance lands at the next safe boundary.
+- Guidance queued **after** the LLM emits `action: "finish"` is lost —
+  the agent already decided it's done.
+- Crash between drain and next checkpoint write → the queued items are
+  in the persisted WM. Crash between checkpoint write and next drain →
+  lost; re-steer after `--resume`.
+
+See `examples/complex_sysaudit_demo.py` for stdin steering across three
+agents alongside HITL on the shell tool.

{react_agent_harness-0.1.0 → react_agent_harness-0.3.0}/agents/base.py

@@ -27,6 +27,7 @@ Token management:
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import json
 import logging
 import uuid
@@ -132,6 +133,7 @@ class BaseAgent:
         guard,
         llm,
         checkpoint_store: Any | None = None,  # FileCheckpointStore / RedisCheckpointStore
+        steering_source_factory: Any | None = None,  # (BaseAgent) -> async ctx mgr
     ) -> None:
         self.config = config
         self.role = config.role  # exposed for orchestrator planner prompt
@@ -145,10 +147,60 @@ class BaseAgent:
         self._task: str = ""
         self._last_think_error: str | None = None
         self._ckp_id: str = ""  # f"{run_id}:{agent_id}" — unique per agent per run
+        # Async steering queue — items drained at the top of each ReAct
+        # step (before checkpoint, before think). Created eagerly so
+        # callers can steer() before run_stream starts.
+        self._steering: asyncio.Queue[str] = asyncio.Queue()
+        # Optional factory: called once at run_stream entry. Must return an
+        # async context manager that, while active, may call agent.steer().
+        # The agent owns the source's lifecycle — no live-instance registry.
+        self._steering_source_factory = steering_source_factory
         self._resume_key: str = (
             ""  # key printed in --resume banner; set by orchestrator to outer run_id
         )
 
+    # ── Async steering ────────────────────────────────────────────────────────
+
+    def steer(self, text: str) -> None:
+        """Inject human guidance to be consumed at the next ReAct step boundary.
+
+        Non-blocking and safe to call concurrently from any coroutine in the
+        same event loop. Drained at the top of the next iteration (before
+        the per-step checkpoint write and before the next think call), then
+        appended to WorkingMemory as a user message and emitted as a
+        HUMAN_GUIDANCE BusEvent.
+
+        Worst-case latency = time remaining in the current tool +
+        next-think duration. Guidance arriving after the LLM has already
+        emitted action="finish" is lost — the agent has decided it's done.
+        """
+        if not text or not text.strip():
+            return
+        self._steering.put_nowait(text.strip())
+
+    async def _drain_steering(self, step: int) -> AsyncGenerator[BusEvent, None]:
+        """Drain any queued guidance into WorkingMemory; yield one event each.
+
+        Called at the top of each ReAct iteration. Items are FIFO. Empty
+        queue is a no-op (zero overhead when no one is steering).
+        """
+        while not self._steering.empty():
+            try:
+                text = self._steering.get_nowait()
+            except asyncio.QueueEmpty:
+                break  # defensive — single consumer, should never fire
+            await self._working_memory.append("user", f"Human guidance: {text}")
+            self._tracer.log(
+                "human_guidance",
+                self.config.agent_id,
+                {"step": step, "text": text},
+            )
+            yield BusEvent(
+                type=EventType.HUMAN_GUIDANCE,
+                agent_id=self.config.agent_id,
+                payload={"step": step, "text": text},
+            )
+
     # ── Streaming entry point (canonical) ─────────────────────────────────────
 
     async def run_stream(
@@ -170,17 +222,25 @@ class BaseAgent:
         await self._working_memory.append("system", system, pinned=True)
         await self._working_memory.append("user", task)
 
-        async with _ResumeHint(
-            self._resume_key,
-            self._checkpoint_store,
-            f"Agent {self.config.agent_id}",
-            check_key=self._ckp_id,
-        ) as hint:
-            async for event in self._run_stream_internal(run_id):
-                if event.type == EventType.TASK_DONE:
-                    await self._clear_checkpoint(run_id)
-                    hint.done = True
-                yield event
+        # Steering source is owned by the agent for the duration of the run.
+        # nullcontext when no factory is configured — zero overhead.
+        source_cm = (
+            self._steering_source_factory(self)
+            if self._steering_source_factory is not None
+            else contextlib.nullcontext()
+        )
+        async with source_cm:
+            async with _ResumeHint(
+                self._resume_key,
+                self._checkpoint_store,
+                f"Agent {self.config.agent_id}",
+                check_key=self._ckp_id,
+            ) as hint:
+                async for event in self._run_stream_internal(run_id):
+                    if event.type == EventType.TASK_DONE:
+                        await self._clear_checkpoint(run_id)
+                        hint.done = True
+                    yield event
 
     async def _resume_stream(
         self,
@@ -203,17 +263,23 @@ class BaseAgent:
                 yield event
             start_step = pending["step"] + 1
 
-        async with _ResumeHint(
-            self._resume_key,
-            self._checkpoint_store,
-            f"Agent {self.config.agent_id}",
-            check_key=self._ckp_id,
-        ) as hint:
-            async for event in self._run_stream_internal(run_id, start_step=start_step):
-                if event.type == EventType.TASK_DONE:
-                    await self._clear_checkpoint(run_id)
-                    hint.done = True
-                yield event
+        source_cm = (
+            self._steering_source_factory(self)
+            if self._steering_source_factory is not None
+            else contextlib.nullcontext()
+        )
+        async with source_cm:
+            async with _ResumeHint(
+                self._resume_key,
+                self._checkpoint_store,
+                f"Agent {self.config.agent_id}",
+                check_key=self._ckp_id,
+            ) as hint:
+                async for event in self._run_stream_internal(run_id, start_step=start_step):
+                    if event.type == EventType.TASK_DONE:
+                        await self._clear_checkpoint(run_id)
+                        hint.done = True
+                    yield event
 
     async def _run_stream_internal(
         self,
@@ -295,6 +361,10 @@ class BaseAgent:
     ) -> AsyncGenerator[BusEvent, None]:
         for step in range(start_step, self.config.max_steps):
             self._guard.check()
+            # Drain steering queue BEFORE the checkpoint write so any
+            # queued guidance is captured by the persisted WM.
+            async for guidance_event in self._drain_steering(step):
+                yield guidance_event
             if (
                 self._checkpoint_store is not None
                 and self.config.checkpoint_every > 0

react_agent_harness-0.3.0/harness/cli.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+from pathlib import Path
+
+from harness.llm.auth import (
+    AnthropicClaudeCodeOAuthClient,
+    AuthFileOAuthProvider,
+    OAuthCredential,
+    OpenAICodexOAuthClient,
+    default_auth_file,
+)
+
+PROVIDERS = ["openai-codex", "claude-code"]
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="agent-harness", description="agent-harness utilities")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    login = sub.add_parser("login", help="log in to a provider")
+    login.add_argument("provider", choices=PROVIDERS)
+    login.add_argument("--auth-file", default=str(default_auth_file()))
+
+    status = sub.add_parser("auth", help="inspect or clear provider auth")
+    status_sub = status.add_subparsers(dest="auth_command", required=True)
+    status_cmd = status_sub.add_parser("status", help="show auth status")
+    status_cmd.add_argument("provider", choices=PROVIDERS)
+    status_cmd.add_argument("--auth-file", default=str(default_auth_file()))
+    logout_cmd = status_sub.add_parser("logout", help="remove auth credentials")
+    logout_cmd.add_argument("provider", choices=PROVIDERS)
+    logout_cmd.add_argument("--auth-file", default=str(default_auth_file()))
+
+    args = parser.parse_args()
+    try:
+        if args.command == "login":
+            if args.provider == "openai-codex":
+                return asyncio.run(_login_openai_codex(Path(args.auth_file).expanduser()))
+            if args.provider == "claude-code":
+                return asyncio.run(_login_claude_code(Path(args.auth_file).expanduser()))
+        if args.command == "auth" and args.auth_command == "status":
+            if args.provider == "openai-codex":
+                return _status_oauth_provider(Path(args.auth_file).expanduser(), "openai-codex")
+            if args.provider == "claude-code":
+                return _status_oauth_provider(Path(args.auth_file).expanduser(), "claude-code")
+        if args.command == "auth" and args.auth_command == "logout":
+            if args.provider == "openai-codex":
+                return _logout_oauth_provider(Path(args.auth_file).expanduser(), "openai-codex")
+            if args.provider == "claude-code":
+                return _logout_oauth_provider(Path(args.auth_file).expanduser(), "claude-code")
+    except Exception as e:
+        print(f"agent-harness: {e}", file=sys.stderr)
+        return 1
+    parser.error("unsupported command")
+    return 2
+
+
+async def _login_openai_codex(path: Path) -> int:
+    client = OpenAICodexOAuthClient()
+    try:
+        device = await client.request_device_code()
+        print("OpenAI Codex login")
+        print(f"Open: {device.verification_uri}")
+        print(f"Code: {device.user_code}")
+        print("Waiting for authorization...")
+        cred = await client.poll_device_code(device)
+    finally:
+        await client.aclose()
+    _write_oauth_credential(path, cred)
+    print(f"Logged in to openai-codex. Credentials saved to {path}")
+    return 0
+
+
+async def _login_claude_code(path: Path) -> int:
+    client = AnthropicClaudeCodeOAuthClient()
+    try:
+        login = client.begin_login()
+        print("Claude Code login")
+        print(f"Open: {login.url}")
+        print("Paste the final callback URL, or the code#state value.")
+        callback_input = input("Callback: ")
+        cred = await client.finish_login(login, callback_input)
+    finally:
+        await client.aclose()
+    _write_oauth_credential(path, cred)
+    print(f"Logged in to claude-code. Credentials saved to {path}")
+    return 0
+
+
+def _status_oauth_provider(path: Path, provider_name: str) -> int:
+    provider = AuthFileOAuthProvider(path, provider=provider_name)
+    try:
+        cred = provider._read_credential()
+    except FileNotFoundError:
+        print(f"Not logged in: {path} does not exist")
+        return 1
+    except Exception as e:
+        print(f"Not logged in: {e}")
+        return 1
+    status = {
+        "provider": provider_name,
+        "auth_file": str(path),
+        "account_id": cred.account_id,
+        "expires_at": cred.expires_at.isoformat() if cred.expires_at else None,
+        "expired": cred.is_expired(),
+    }
+    print(json.dumps(status, indent=2))
+    return 0
+
+
+def _logout_oauth_provider(path: Path, provider_name: str) -> int:
+    provider = AuthFileOAuthProvider(
+        path, provider=provider_name, require_private_permissions=False
+    )
+    provider.clear()
+    print(f"Removed {provider_name} credentials from {path}")
+    return 0
+
+
+def _write_oauth_credential(path: Path, cred: OAuthCredential) -> None:
+    provider = AuthFileOAuthProvider(
+        path, provider=cred.provider, require_private_permissions=False
+    )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not path.exists():
+        path.write_text("{}")
+        if os.name != "nt":
+            path.chmod(0o600)
+    provider._write_credential(cred)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{react_agent_harness-0.1.0 → react_agent_harness-0.3.0}/harness/events.py

@@ -18,6 +18,7 @@ Event lifecycle within a single goal:
   Orchestrated path (run / run_stream):
     PLAN                  — orchestrator emitted a static DAG
     (per task in DAG)
+        HUMAN_GUIDANCE?   — async steering drained at top of step
         THOUGHT           — agent's next-step reasoning
         TOKEN*            — partial LLM output (only when client streams)
         ACTION            — agent chose a tool + args
@@ -46,6 +47,7 @@ class EventType(str, Enum):
     TOKEN = "token"
     ACTION = "action"
     OBSERVATION = "observation"
+    HUMAN_GUIDANCE = "human_guidance"  # async steering injected at step boundary
     TASK_DONE = "task_done"
     REPLAN = "replan"
     SYNTHESIS = "synthesis"

{react_agent_harness-0.1.0 → react_agent_harness-0.3.0}/harness/hitl.py

@@ -176,14 +176,48 @@ async def request_approval(
 
     Holds stdout_lock for the duration so concurrent agent events don't
     interleave with the banner or the input prompt.
+
+    Input always goes through prompt_toolkit:
+      - If a steering router is active, HITL claims the next stdin read
+        via the router. Text submitted at the active steering prompt is
+        routed to HITL instead of subscribers; if the router reaches a
+        pending claim between steering prompt cycles, it shows HITL's
+        approval prompt directly.
+      - If no router is active, HITL spins up a one-shot PromptSession
+        for the approval prompt. Same UX either way.
     """
+    from harness.steering import get_active_router
+
     async with stdout_lock:
+        router = get_active_router()
+        approve_prompt = "  Approve? [y/n/a/correction]: "
+        # If a router is active, reserve the next stdin read BEFORE printing
+        # the banner so the user's typed answer routes to HITL (not steering).
+        hitl_future: Any = (
+            router.claim_next_line(prompt=approve_prompt) if router is not None else None
+        )
+
         _print_banner(req)
 
         guard.suspend()
         try:
-            loop = asyncio.get_running_loop()
-            raw = await loop.run_in_executor(None, input, "  Approve? [y/n/a/correction]: ")
+            if hitl_future is not None:
+                raw = await hitl_future
+            else:
+                # Standalone: one-shot prompt_toolkit session with the same
+                # Enter-submits / Ctrl+J-newline bindings as steering so
+                # single-token answers (y/n/a) and multi-line corrections
+                # both compose naturally.
+                from prompt_toolkit import PromptSession
+
+                from harness.steering import StdinRouter
+
+                session: PromptSession = PromptSession()
+                raw = await session.prompt_async(
+                    approve_prompt,
+                    multiline=True,
+                    key_bindings=StdinRouter._build_key_bindings(),
+                )
         finally:
             guard.resume()
 

react_agent_harness-0.3.0/harness/llm/__init__.py

@@ -0,0 +1,19 @@
+"""LLM adapter helpers."""
+
+from harness.llm.auth import (
+    AnthropicClaudeCodeOAuthClient,
+    AuthFileOAuthProvider,
+    OAuthCredential,
+    OpenAICodexOAuthClient,
+)
+from harness.llm.claude_code import ClaudeCodeLLM
+from harness.llm.openai_codex import OpenAICodexLLM
+
+__all__ = [
+    "AnthropicClaudeCodeOAuthClient",
+    "AuthFileOAuthProvider",
+    "ClaudeCodeLLM",
+    "OAuthCredential",
+    "OpenAICodexLLM",
+    "OpenAICodexOAuthClient",
+]

react_agent_harness-0.3.0/harness/llm/_streaming.py

@@ -0,0 +1,56 @@
+"""Shared SSE helpers for streaming-capable LLM adapters."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from typing import Any
+
+
+async def aiter_sse_events(response: Any) -> AsyncGenerator[tuple[str, str], None]:
+    """Yield (event_type, data) pairs from an SSE response.
+
+    Parses the standard `event:` / `data:` line format. Blank lines
+    terminate events. The default event type for unlabelled events is
+    `"message"`. Trailing buffered data (no terminating blank line) is
+    flushed when the stream ends.
+    """
+    current_event = "message"
+    data_lines: list[str] = []
+    async for raw_line in response.aiter_lines():
+        line = raw_line.rstrip("\r")
+        if not line:
+            if data_lines:
+                yield current_event, "\n".join(data_lines)
+                current_event = "message"
+                data_lines = []
+            continue
+        if line.startswith("event:"):
+            current_event = line[len("event:") :].strip()
+        elif line.startswith("data:"):
+            data_lines.append(line[len("data:") :].strip())
+    if data_lines:
+        yield current_event, "\n".join(data_lines)
+
+
+async def read_error_body(response: Any) -> bytes:
+    """Drain the body of an error response, returning at most 4 KiB."""
+    out: list[bytes] = []
+    total = 0
+    async for chunk in response.aiter_bytes():
+        if total >= 4096:
+            break
+        out.append(chunk)
+        total += len(chunk)
+    return b"".join(out)[:4096]
+
+
+def format_streaming_error(status_code: int, body: bytes, *, provider: str) -> str:
+    """Build a user-facing error message from an error response body.
+
+    Truncates aggressively because error bodies sometimes echo request
+    payloads — we don't want bearer tokens or full prompts in tracebacks.
+    """
+    text = body.decode(errors="replace").strip()
+    if not text:
+        return f"{provider} backend returned HTTP {status_code}"
+    return f"{provider} backend returned {status_code}: {text[:500]}"