hud 0.6.18.dev2__tar.gz → 0.6.19.dev2__tar.gz

{hud-0.6.18.dev2 → hud-0.6.19.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hud
-Version: 0.6.18.dev2
+Version: 0.6.19.dev2
 Summary: SDK for the HUD platform.
 Project-URL: Homepage, https://github.com/hud-evals/hud-python
 Project-URL: Bug Tracker, https://github.com/hud-evals/hud-python/issues
@@ -38,7 +38,7 @@ Requires-Dist: anthropic>=0.98.0
 Requires-Dist: asyncssh>=2.23.0
 Requires-Dist: asyncvnc>=1.3.0
 Requires-Dist: fastmcp==3.2.0
-Requires-Dist: google-genai
+Requires-Dist: google-genai>=1.75.0
 Requires-Dist: httpx2<3,>=2.0.0
 Requires-Dist: httpx<1,>=0.23.0
 Requires-Dist: mcp<2.0,>=1.24.0
@@ -199,19 +199,6 @@ Each graded evaluation is a **trace** (the SDK's live handle is a `Run`). With `
 
 → [Quickstart](https://docs.hud.ai/v6/start/quickstart) · [Tasks & tasksets](https://docs.hud.ai/v6/reference/tasks)
 
-## Existing benchmarks
-
-The experimental `hud.integrations.harbor` adapter turns Harbor task directories into runnable HUD
-tasksets and can export authored HUD tasks back to Harbor folders.
-
-```python
-from hud.integrations import harbor
-
-taskset = await harbor.adapt("./benchmark")
-```
-
-→ [Harbor interop](https://docs.hud.ai/v6/advanced/harbor-convert)
-
 ## Capabilities & harnesses
 
 A **capability** is a connection the environment exposes; a **harness** attaches its own tools to it. The same environment serves a one-shot Q&A or a full computer-use rollout, depending on which capabilities the harness opens.
@@ -234,6 +221,17 @@ A **capability** is a connection the environment exposes; a **harness** attaches
 
 From the [platform UI](https://hud.ai) you can run batches, compare models on the same taskset, and inspect every trace.
 
+Hosted Claude Code and Codex harnesses reach platform inference through an
+environment-owned, workspace-local endpoint. The endpoint is available only to
+`bwrap` workspaces with network isolation and is bound to the exact CLI process
+selected by the harness. Platform credentials stay in the environment-owned
+relay rather than the CLI environment, workspace manifest, or child processes.
+Codex therefore uses the environment sandbox instead of starting a nested
+Codex sandbox for process-bound hosted execution.
+The workspace probes its substrate and uses either seccomp notification or a
+ptrace-backed seccomp guard; it does not advertise process-bound connections
+when neither enforcement backend is available.
+
 → [Run & deploy](https://docs.hud.ai/v6/reference/runtime)
 
 ## Train on rewards

{hud-0.6.18.dev2 → hud-0.6.19.dev2}/README.md

@@ -113,19 +113,6 @@ Each graded evaluation is a **trace** (the SDK's live handle is a `Run`). With `
 
 → [Quickstart](https://docs.hud.ai/v6/start/quickstart) · [Tasks & tasksets](https://docs.hud.ai/v6/reference/tasks)
 
-## Existing benchmarks
-
-The experimental `hud.integrations.harbor` adapter turns Harbor task directories into runnable HUD
-tasksets and can export authored HUD tasks back to Harbor folders.
-
-```python
-from hud.integrations import harbor
-
-taskset = await harbor.adapt("./benchmark")
-```
-
-→ [Harbor interop](https://docs.hud.ai/v6/advanced/harbor-convert)
-
 ## Capabilities & harnesses
 
 A **capability** is a connection the environment exposes; a **harness** attaches its own tools to it. The same environment serves a one-shot Q&A or a full computer-use rollout, depending on which capabilities the harness opens.
@@ -148,6 +135,17 @@ A **capability** is a connection the environment exposes; a **harness** attaches
 
 From the [platform UI](https://hud.ai) you can run batches, compare models on the same taskset, and inspect every trace.
 
+Hosted Claude Code and Codex harnesses reach platform inference through an
+environment-owned, workspace-local endpoint. The endpoint is available only to
+`bwrap` workspaces with network isolation and is bound to the exact CLI process
+selected by the harness. Platform credentials stay in the environment-owned
+relay rather than the CLI environment, workspace manifest, or child processes.
+Codex therefore uses the environment sandbox instead of starting a nested
+Codex sandbox for process-bound hosted execution.
+The workspace probes its substrate and uses either seccomp notification or a
+ptrace-backed seccomp guard; it does not advertise process-bound connections
+when neither enforcement backend is available.
+
 → [Run & deploy](https://docs.hud.ai/v6/reference/runtime)
 
 ## Train on rewards

{hud-0.6.18.dev2 → hud-0.6.19.dev2}/hud/__init__.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 # Apply patches to third-party libraries early, before other imports
 from . import patches as _patches  # noqa: F401
+from .capabilities import Connection
 from .clients import connect
 from .environment import Environment
 from .eval import (
@@ -38,6 +39,7 @@ from .version import __version__
 __all__ = [
     "Chat",
     "ComposeProject",
+    "Connection",
     "DockerRuntime",
     "Environment",
     "Grade",

{hud-0.6.18.dev2 → hud-0.6.19.dev2}/hud/agents/__init__.py

@@ -1,7 +1,4 @@
-"""Agent implementations.
-
-The robot policy harness lives in :mod:`hud.agents.robot` (requires the ``robot`` extra).
-"""
+"""Agent implementations."""
 
 from __future__ import annotations
 
@@ -15,13 +12,16 @@ from hud.utils.gateway import resolve_gateway_model
 if TYPE_CHECKING:
     from typing import TypeAlias
 
-    from hud.agents.claude import ClaudeAgent, ClaudeSDKAgent, ClaudeSDKConfig
+    from hud.agents.claude import ClaudeAgent, ClaudeCLIAgent, ClaudeCLIConfig
+    from hud.agents.codex import CodexCLIAgent, CodexCLIConfig
     from hud.agents.gemini import GeminiAgent
     from hud.agents.openai import OpenAIAgent
     from hud.agents.openai_compatible import OpenAIChatAgent
     from hud.agents.tool_agent import ToolAgent as MCPAgent
 
-    GatewayAgent: TypeAlias = ClaudeAgent | GeminiAgent | OpenAIAgent | OpenAIChatAgent
+    GatewayAgent: TypeAlias = (
+        ClaudeAgent | ClaudeCLIAgent | CodexCLIAgent | GeminiAgent | OpenAIAgent | OpenAIChatAgent
+    )
 
 
 def create_agent(model: str, **kwargs: Any) -> GatewayAgent:
@@ -46,44 +46,22 @@ def create_agent(model: str, **kwargs: Any) -> GatewayAgent:
     if not settings.api_key:
         raise HudAuthenticationError("HUD_API_KEY is required to create a gateway agent")
 
-    agent_type, model_id = resolve_agent_model(model)
-    kwargs.setdefault("model", model_id)
-    kwargs["gateway"] = True
-    # cls/config_cls are matched unions; the pairing is correct by construction.
-    config = agent_type.config_cls(**kwargs)
-    return agent_type.cls(cast("Any", config))
-
-
-def resolve_agent_model(model: str) -> tuple[AgentType, str]:
-    """Resolve a catalog id/name/slug or an agent type without constructing a client."""
-    agent_type = next((candidate for candidate in AgentType if candidate.value == model), None)
-    if agent_type is not None:
-        return agent_type, model
-    try:
+    if model in {member.value for member in AgentType}:
+        agent_type = AgentType(model)
+    else:
         entry = resolve_gateway_model(model)
-    except HudAuthenticationError:
-        types = ", ".join(candidate.value for candidate in AgentType)
-        raise ValueError(
-            f"Resolving {model!r} needs the HUD model catalog; set HUD_API_KEY, or pass an "
-            f"agent type ({types}) and choose the model with its config."
-        ) from None
-    if entry.sdk_agent_type in ("operator", "gemini_cua"):
-        replacement = "openai" if entry.sdk_agent_type == "operator" else "gemini"
-        raise ValueError(
-            f"The {entry.sdk_agent_type} agent is no longer supported; use {replacement} with a "
-            "supported computer-use model."
-        )
-    try:
         agent_type = AgentType(entry.sdk_agent_type)
-    except ValueError as exc:
-        raise ValueError(f"Model {model!r} has invalid agent type metadata") from exc
-    return agent_type, entry.model_name or model
+        kwargs.setdefault("model", entry.model_name or model)
+    kwargs["gateway"] = True
+    return cast("GatewayAgent", agent_type.cls.load(kwargs))
 
 
 _LAZY_EXPORTS = {
     "ClaudeAgent": ("hud.agents.claude", "ClaudeAgent"),
-    "ClaudeSDKAgent": ("hud.agents.claude", "ClaudeSDKAgent"),
-    "ClaudeSDKConfig": ("hud.agents.claude", "ClaudeSDKConfig"),
+    "ClaudeCLIAgent": ("hud.agents.claude", "ClaudeCLIAgent"),
+    "ClaudeCLIConfig": ("hud.agents.claude", "ClaudeCLIConfig"),
+    "CodexCLIAgent": ("hud.agents.codex", "CodexCLIAgent"),
+    "CodexCLIConfig": ("hud.agents.codex", "CodexCLIConfig"),
     "GeminiAgent": ("hud.agents.gemini", "GeminiAgent"),
     "MCPAgent": ("hud.agents.tool_agent", "ToolAgent"),
     "OpenAIAgent": ("hud.agents.openai", "OpenAIAgent"),
@@ -92,14 +70,15 @@ _LAZY_EXPORTS = {
 
 __all__ = [
     "ClaudeAgent",
-    "ClaudeSDKAgent",
-    "ClaudeSDKConfig",
+    "ClaudeCLIAgent",
+    "ClaudeCLIConfig",
+    "CodexCLIAgent",
+    "CodexCLIConfig",
     "GeminiAgent",
     "MCPAgent",
     "OpenAIAgent",
     "OpenAIChatAgent",
     "create_agent",
-    "resolve_agent_model",
 ]
 
 

hud-0.6.19.dev2/hud/agents/base.py

@@ -0,0 +1,47 @@
+"""Agent ABC: the rollout contract."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, ClassVar, Generic, Self, cast
+
+from typing_extensions import TypeVar
+
+from hud.agents.types import AgentConfig
+
+if TYPE_CHECKING:
+    from hud.eval.run import Run
+    from hud.utils.serialization import JsonObject
+
+ConfigT_co = TypeVar("ConfigT_co", bound=AgentConfig, covariant=True, default=AgentConfig)
+
+
+class Agent(ABC, Generic[ConfigT_co]):
+    """Drives a live ``Run`` by recording its trajectory and final answer.
+
+    Subclasses implement ``__call__(run)``; callers do ``await agent(run)``. Stateless
+    per run — everything comes from ``run`` — so one instance drives many concurrent
+    rollouts. The caller owns lifecycle status, cancellation, and grading.
+
+    ``config`` is the agent's serializable identity: :meth:`dump` writes it and
+    :meth:`load` rebuilds the agent from it. Subclasses parametrize ``Agent[XConfig]``,
+    set ``config_cls = XConfig`` for construction, and, when they override
+    ``__init__``, call ``super().__init__(config)``.
+    """
+
+    config_cls: ClassVar[type[AgentConfig]] = AgentConfig
+    config: ConfigT_co
+
+    def __init__(self, config: ConfigT_co | None = None) -> None:
+        self.config = config or cast("ConfigT_co", self.config_cls())
+
+    @abstractmethod
+    async def __call__(self, run: Run) -> None:
+        """Fill ``run.trace`` with the trajectory and final answer."""
+
+    def dump(self) -> JsonObject:
+        return self.config.model_dump(mode="json")
+
+    @classmethod
+    def load(cls, data: JsonObject) -> Self:
+        return cls(cast("ConfigT_co", cls.config_cls.model_validate(data)))

{hud-0.6.18.dev2 → hud-0.6.19.dev2}/hud/agents/browser_use/agent.py

@@ -24,7 +24,6 @@ from urllib.parse import urlsplit, urlunsplit
 from hud.agents.base import Agent
 from hud.agents.types import AgentStep, BrowserUseConfig
 from hud.settings import settings
-from hud.types import Step
 
 if TYPE_CHECKING:
     from hud.eval.run import Run
@@ -72,13 +71,10 @@ class _BrowserUseModule(Protocol):
     Agent: _AgentFactory
 
 
-class BrowserUseAgent(Agent):
+class BrowserUseAgent(Agent[BrowserUseConfig]):
     """Run the ``browser-use`` agent against an env's ``cdp/1.3`` capability."""
 
-    config: BrowserUseConfig
-
-    def __init__(self, config: BrowserUseConfig | None = None) -> None:
-        self.config = config or BrowserUseConfig()
+    config_cls = BrowserUseConfig
 
     async def __call__(self, run: Run) -> None:
         """Drive browser-use over the run's CDP capability, filling ``run.trace``.
@@ -107,18 +103,12 @@ class BrowserUseAgent(Agent):
 
         try:
             history = await sdk_agent.run(max_steps=self.config.max_steps)
-        except Exception as exc:
-            LOGGER.exception("browser-use run failed")
-            trace.status = "error"
-            run.record(Step(source="system", error=str(exc)))
-            return
         finally:
             with contextlib.suppress(Exception):
                 await browser.stop()
 
         successful = history.is_successful()
         content = history.final_result() or ""
-        trace.status = "error" if successful is False else "completed"
         trace.content = content
         trace.extra.update(
             {
@@ -133,7 +123,6 @@ class BrowserUseAgent(Agent):
             AgentStep(
                 content=content,
                 done=history.is_done(),
-                error=content if successful is False else None,
             ),
         )
 

{hud-0.6.18.dev2 → hud-0.6.19.dev2}/hud/agents/claude/__init__.py

@@ -7,15 +7,15 @@ from .agent import (
     AsyncAnthropicBedrock,
     ClaudeAgent,
 )
-from .sdk import ClaudeSDKAgent, ClaudeSDKConfig
+from .sdk import ClaudeCLIAgent, ClaudeCLIConfig
 from .tools import ClaudeToolSearchTool, ClaudeWebFetchTool, ClaudeWebSearchTool
 
 __all__ = [
     "AsyncAnthropic",
     "AsyncAnthropicBedrock",
     "ClaudeAgent",
-    "ClaudeSDKAgent",
-    "ClaudeSDKConfig",
+    "ClaudeCLIAgent",
+    "ClaudeCLIConfig",
     "ClaudeToolSearchTool",
     "ClaudeWebFetchTool",
     "ClaudeWebSearchTool",

{hud-0.6.18.dev2 → hud-0.6.19.dev2}/hud/agents/claude/agent.py

@@ -8,7 +8,7 @@ import json
 import logging
 import math
 from random import SystemRandom
-from typing import TYPE_CHECKING, Literal, cast
+from typing import TYPE_CHECKING, cast
 
 import httpx
 import httpx2
@@ -23,7 +23,6 @@ from anthropic import (
 )
 from anthropic.types import CacheControlEphemeralParam
 from anthropic.types.beta import (
-    BetaBase64ImageSourceParam,
     BetaBase64PDFSourceParam,
     BetaImageBlockParam,
     BetaMessage,
@@ -35,12 +34,14 @@ from anthropic.types.beta import (
     BetaToolResultBlockParam,
     BetaToolUnionParam,
 )
+from PIL import Image
 
 from hud.agents.tool_agent import RunState, ToolAgent
 from hud.agents.types import AgentStep, Citation, ClaudeConfig, Usage
 from hud.types import MCPToolCall, MCPToolResult
 from hud.utils import gateway
 
+from .images import image_source
 from .tools.coding import ClaudeBashTool, ClaudeTextEditorTool
 from .tools.computer import ClaudeComputerTool
 from .tools.mcp_proxy import ClaudeMCPProxyTool
@@ -48,9 +49,9 @@ from .tools.mcp_proxy import ClaudeMCPProxyTool
 if TYPE_CHECKING:
     from anthropic.types.beta import BetaTextCitation
 
+
 logger = logging.getLogger(__name__)
 
-ClaudeImageMediaType = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
 ClaudeToolResultContent = BetaTextBlockParam | BetaImageBlockParam | BetaRequestDocumentBlockParam
 
 _RETRYABLE_STREAM_ERROR_TYPES = frozenset(
@@ -93,6 +94,7 @@ def _stream_retry_delay(attempt: int, error: Exception) -> float:
 class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
     """Anthropic Claude agent. Drives SSH (coding), RFB (computer), and MCP capabilities."""
 
+    config_cls = ClaudeConfig
     tool_catalog = (
         ClaudeBashTool,
         ClaudeTextEditorTool,
@@ -101,7 +103,7 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
     )
 
     def __init__(self, config: ClaudeConfig | None = None) -> None:
-        self.config = config or ClaudeConfig()
+        super().__init__(config)
         self.anthropic_client: AsyncAnthropic | AsyncAnthropicBedrock = self._resolve_client()
 
     def _resolve_client(self) -> AsyncAnthropic | AsyncAnthropicBedrock:
@@ -138,6 +140,7 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
             return None
 
         result_content = result.content
+        image_error = False
         if result.isError:
             error_msg = next(
                 (c.text for c in result.content if isinstance(c, mcp_types.TextContent)),
@@ -166,14 +169,19 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
                             citations={"enabled": True},
                         )
                 case mcp_types.ImageContent():
-                    block = BetaImageBlockParam(
-                        type="image",
-                        source=BetaBase64ImageSourceParam(
-                            type="base64",
-                            media_type=cast("ClaudeImageMediaType", content.mimeType),
-                            data=content.data,
-                        ),
-                    )
+                    try:
+                        block = BetaImageBlockParam(
+                            type="image",
+                            source=image_source(
+                                content,
+                                preserve_dimensions=isinstance(
+                                    state.tools.get(call.name), ClaudeComputerTool
+                                ),
+                            ),
+                        )
+                    except (ValueError, OSError, Image.DecompressionBombError) as exc:
+                        image_error = True
+                        block = BetaTextBlockParam(type="text", text=f"Cannot view image: {exc}")
                 case mcp_types.EmbeddedResource(
                     resource=mcp_types.BlobResourceContents(mimeType="application/pdf") as resource,
                 ):
@@ -205,6 +213,7 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
                     type="tool_result",
                     tool_use_id=tool_use_id,
                     content=claude_blocks,
+                    is_error=bool(result.isError) or image_error,
                 ),
             ],
         )
@@ -360,26 +369,36 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
         if response is None:
             raise ValueError("Claude response missing after retries")
 
-        result = AgentStep(content="", done=True)
-        result.model = response.model
-        result.usage = Usage(
-            prompt_tokens=response.usage.input_tokens,
-            completion_tokens=response.usage.output_tokens,
-            cached_tokens=response.usage.cache_read_input_tokens,
+        return self.message_to_agent_step(response, citations_enabled=citations_enabled)
+
+    @classmethod
+    def message_to_agent_step(
+        cls,
+        response: BetaMessage,
+        *,
+        citations_enabled: bool = False,
+    ) -> AgentStep:
+        result = AgentStep(
+            content="",
+            done=True,
+            model=response.model,
+            usage=Usage(
+                prompt_tokens=response.usage.input_tokens,
+                completion_tokens=response.usage.output_tokens,
+                cached_tokens=response.usage.cache_read_input_tokens,
+            ),
         )
         text_parts: list[str] = []
         thinking_parts: list[str] = []
-        citations: list[Citation] = []
 
         for block in response.content:
             match block.type:
                 case "tool_use":
-                    arguments = dict(block.input) if block.input else {}
                     result.tool_calls.append(
                         MCPToolCall(
                             id=block.id,
                             name=block.name,
-                            arguments=arguments,
+                            arguments=dict(block.input) if block.input else {},
                             _meta=mcp_types.RequestParams.Meta.model_validate(
                                 {"citations_enabled": citations_enabled},
                             ),
@@ -387,9 +406,8 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
                     )
                     result.done = False
                 case "text":
-                    text_block = block
-                    text_parts.append(text_block.text)
-                    citations.extend(self._citation(c) for c in (text_block.citations or []))
+                    text_parts.append(block.text)
+                    result.citations.extend(cls._citation(c) for c in (block.citations or []))
                 case "thinking":
                     if block.thinking:
                         thinking_parts.append(block.thinking)
@@ -397,7 +415,6 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
                     pass
 
         result.content = "".join(text_parts)
-        result.citations = citations
         if thinking_parts:
             result.reasoning = "\n".join(thinking_parts)
         result.finish_reason = response.stop_reason

hud-0.6.19.dev2/hud/agents/claude/images.py

@@ -0,0 +1,65 @@
+"""Image input preparation for Anthropic Messages."""
+
+from __future__ import annotations
+
+import base64
+import math
+from io import BytesIO
+from typing import TYPE_CHECKING, Literal, cast
+
+from anthropic.types.beta import BetaBase64ImageSourceParam
+from PIL import Image, ImageOps
+
+if TYPE_CHECKING:
+    from mcp.types import ImageContent
+
+ClaudeImageMediaType = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
+MAX_SOURCE_IMAGE_PIXELS = 16_000_000
+MAX_IMAGE_EDGE = 1568
+MAX_IMAGE_PIXELS = 1_150_000
+MAX_IMAGE_BASE64_BYTES = 5_000_000
+
+
+def image_source(
+    content: ImageContent, *, preserve_dimensions: bool = False
+) -> BetaBase64ImageSourceParam:
+    """Prepare a tool image, preserving computer-tool coordinate space when requested."""
+    if preserve_dimensions:
+        return BetaBase64ImageSourceParam(
+            type="base64",
+            media_type=cast("ClaudeImageMediaType", content.mimeType),
+            data=content.data,
+        )
+    with Image.open(BytesIO(base64.b64decode(content.data, validate=True))) as image:
+        if image.width * image.height > MAX_SOURCE_IMAGE_PIXELS:
+            raise ValueError(
+                f"Image exceeds the {MAX_SOURCE_IMAGE_PIXELS:,}-pixel source limit. "
+                "Resize or crop it before viewing."
+            )
+        return _encode_image(image)
+
+
+def _encode_image(image: Image.Image) -> BetaBase64ImageSourceParam:
+    scale = min(
+        1.0,
+        MAX_IMAGE_EDGE / max(image.size),
+        math.sqrt(MAX_IMAGE_PIXELS / (image.width * image.height)),
+    )
+    image.thumbnail(
+        (max(1, int(image.width * scale)), max(1, int(image.height * scale))),
+        Image.Resampling.LANCZOS,
+    )
+    image = ImageOps.exif_transpose(image)
+    image = image.convert("RGBA" if image.has_transparency_data else "RGB")
+    buffer = BytesIO()
+    image.save(buffer, format="PNG", optimize=True)
+    data = base64.b64encode(buffer.getvalue()).decode("ascii")
+    mime_type: ClaudeImageMediaType = "image/png"
+    if len(data) > MAX_IMAGE_BASE64_BYTES:
+        background = Image.new("RGB", image.size, "white")
+        background.paste(image, mask=image.getchannel("A") if image.mode == "RGBA" else None)
+        buffer = BytesIO()
+        background.save(buffer, format="JPEG", quality=85, optimize=True)
+        data = base64.b64encode(buffer.getvalue()).decode("ascii")
+        mime_type = "image/jpeg"
+    return BetaBase64ImageSourceParam(type="base64", media_type=mime_type, data=data)

hud-0.6.19.dev2/hud/agents/claude/sdk/__init__.py

@@ -0,0 +1,7 @@
+"""Agent that runs the ``claude`` CLI over SSH."""
+
+from hud.agents.types import ClaudeCLIConfig
+
+from .agent import ClaudeCLIAgent
+
+__all__ = ["ClaudeCLIAgent", "ClaudeCLIConfig"]