q792602257
a68f609453
Implements all 19 tasks of the cloud-planner-proxy OpenSpec change:
- Cloud API: cloud.planner_config (CloudPlannerConfig, load/build helpers)
reusing runtime.tool_calling_client provider clients (no new dependency
needed -- device-cloud-platform already depends on device-agent-runtime).
- Cloud API: new host-scoped POST /internal/v1/hosts/{host_id}/planner/decide
internal endpoint, reusing existing bearer auth; logs only metadata
(host id, tool name, latency, error class), never prompt/screenshot
content.
- Host Agent: new AI_PLANNER_TRANSPORT config (direct default | cloud) and
host_agent/cloud_planner_client.py::CloudProxyToolCallingClient, a
synchronous ToolCallingClient implementation (structural, not importing
runtime) that calls the new endpoint via its own httpx.Client -- avoids
bridging the async HostAgentClient across the worker-thread boundary
that AIPlanner.plan() runs in (asyncio.to_thread in lease.py).
- Host Agent wiring: create_execution_factories()/_host_agent_planner()
select the cloud-proxy client only when AI_PLANNER_TRANSPORT=cloud;
direct/unset transport is unchanged (still the default).
- Tests: 22 new tests across Cloud API config, the new endpoint, the new
client, and transport-selection wiring; full non-integration suite
(492 tests) passes with no regressions.
- Docs: docs/CLOUD_DEPLOYMENT.md documents the cloud transport, its
trade-offs, and the credential split between Host Agent and Cloud API.
proposal.md/design.md were corrected during implementation to reflect two
findings: no new anthropic/openai dependency is actually needed, and
CloudProxyToolCallingClient uses its own sync httpx.Client rather than a
new HostAgentClient method, per the thread-boundary reasoning above.
87 lines
2.7 KiB
Python
87 lines
2.7 KiB
Python
"""Cloud Control Plane's own AI Planner provider configuration.
|
|
|
|
Analogous to ``runtime/planner_config.py``, but loaded from the Cloud API's
|
|
own process environment rather than a Host Agent's. There is no ``enabled``
|
|
flag here: the planner-decision endpoint always exists once the Cloud API is
|
|
running, and simply fails a given request if the configured provider call
|
|
fails (see ``cloud.internal_api.api``). Provider API keys
|
|
(``ANTHROPIC_API_KEY``/``OPENAI_API_KEY``) are not modeled as fields here --
|
|
like the Host Agent's direct-transport path, they are read implicitly by the
|
|
``anthropic``/``openai`` SDK clients from the process environment.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
from collections.abc import Mapping
|
|
from dataclasses import dataclass
|
|
|
|
from runtime.tool_calling_client import (
|
|
AnthropicToolCallingClient,
|
|
OpenAIToolCallingClient,
|
|
ToolCallingClient,
|
|
)
|
|
|
|
DEFAULT_PROVIDER = "anthropic"
|
|
DEFAULT_MODEL_BY_PROVIDER = {
|
|
"anthropic": "claude-sonnet-5",
|
|
"openai": "gpt-5.6",
|
|
}
|
|
DEFAULT_TIMEOUT_SECONDS = 30.0
|
|
|
|
PROVIDER_ENV = "AI_PLANNER_PROVIDER"
|
|
MODEL_ENV = "AI_PLANNER_MODEL"
|
|
TIMEOUT_ENV = "AI_PLANNER_TIMEOUT_SECONDS"
|
|
|
|
SUPPORTED_PROVIDERS = frozenset(DEFAULT_MODEL_BY_PROVIDER)
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class CloudPlannerConfig:
|
|
provider: str = DEFAULT_PROVIDER
|
|
model: str = ""
|
|
timeout: float = DEFAULT_TIMEOUT_SECONDS
|
|
|
|
def resolved_model(self) -> str:
|
|
return self.model or DEFAULT_MODEL_BY_PROVIDER[self.provider]
|
|
|
|
|
|
def load_cloud_planner_config(
|
|
env: Mapping[str, str] | None = None,
|
|
) -> CloudPlannerConfig:
|
|
values = env or os.environ
|
|
return CloudPlannerConfig(
|
|
provider=_parse_provider(values.get(PROVIDER_ENV)),
|
|
model=values.get(MODEL_ENV) or "",
|
|
timeout=_parse_timeout(values.get(TIMEOUT_ENV)),
|
|
)
|
|
|
|
|
|
def build_cloud_planner_client(config: CloudPlannerConfig) -> ToolCallingClient:
|
|
"""Construct the same provider client the Host Agent's direct transport uses.
|
|
|
|
Reuses ``runtime.tool_calling_client``'s Anthropic/OpenAI wire-format
|
|
translation (see design decision D1) instead of a second implementation.
|
|
"""
|
|
model = config.resolved_model()
|
|
if config.provider == "openai":
|
|
return OpenAIToolCallingClient(model=model)
|
|
return AnthropicToolCallingClient(model=model)
|
|
|
|
|
|
def _parse_provider(value: str | None) -> str:
|
|
if value is None:
|
|
return DEFAULT_PROVIDER
|
|
provider = value.strip().lower()
|
|
return provider if provider in SUPPORTED_PROVIDERS else DEFAULT_PROVIDER
|
|
|
|
|
|
def _parse_timeout(value: str | None) -> float:
|
|
if value is None:
|
|
return DEFAULT_TIMEOUT_SECONDS
|
|
try:
|
|
timeout = float(value)
|
|
except ValueError:
|
|
return DEFAULT_TIMEOUT_SECONDS
|
|
return timeout if timeout > 0 else DEFAULT_TIMEOUT_SECONDS
|