api-operator 0.9.0__tar.gz → 0.10.0__tar.gz

{api_operator-0.9.0 → api_operator-0.10.0}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.10.0] - 2026-06-15
+
+### Added
+
+- YAML adapter `connect_host` — route HTTP to an internal host (e.g. Docker `nginx`) while preserving logical `Host` headers for multi-tenant subdomains
+- Optional CORS for `api-operator serve` via `API_OPERATOR_CORS_ORIGINS` (comma-separated)
+- `Dockerfile` for containerized deployments
+- `formatters.py` — human-readable tool success messages (no raw JSON in chat replies)
+- Mock adapter tools: `get_usage`, `get_subscription`
+
+### Changed
+
+- Mock planner — friendlier help text and NL patterns for tenant-kit flows
+- FastAPI app version metadata updated to 0.10.0
+
 ## [0.9.0] - 2026-06-14
 
 Renamed to **`api-operator`** (GitHub + PyPI). PyPI blocks names starting with `operator` (stdlib conflict).

api_operator-0.10.0/Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY pyproject.toml README.md LICENSE ./
+COPY api_operator ./api_operator
+
+RUN pip install --no-cache-dir .
+
+EXPOSE 8100
+
+CMD ["api-operator", "serve", "--host", "0.0.0.0", "--port", "8100", "--adapter", "yaml", "--planner", "mock"]

{api_operator-0.9.0 → api_operator-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-operator
-Version: 0.9.0
+Version: 0.10.0
 Summary: Standalone AI API Operator with pluggable adapters for multi-project APIs
 Project-URL: Homepage, https://github.com/mohammedelkarsh/api-operator
 Project-URL: Repository, https://github.com/mohammedelkarsh/api-operator

{api_operator-0.9.0 → api_operator-0.10.0}/api_operator/adapters/mock.py

@@ -62,6 +62,24 @@ class MockAdapter(Adapter):
                 parameters={},
             )
         )
+        registry.register(
+            Tool(
+                name="get_usage",
+                description="Get usage metrics for a workspace",
+                handler=self._get_usage,
+                parameters={"workspace_id": str},
+                required=["workspace_id"],
+            )
+        )
+        registry.register(
+            Tool(
+                name="get_subscription",
+                description="Get subscription details for a workspace",
+                handler=self._get_subscription,
+                parameters={"workspace_id": str},
+                required=["workspace_id"],
+            )
+        )
         registry.register(
             Tool(
                 name="provision_link",
@@ -121,6 +139,24 @@ class MockAdapter(Adapter):
         items = list(_MockStore.connections.values())
         return ToolResult(ok=True, data={"connections": items, "count": len(items)})
 
+    async def _get_usage(self, workspace_id: str) -> ToolResult:
+        key = workspace_id.strip().lower()
+        if key not in _MockStore.workspaces and key != "demo":
+            return ToolResult(ok=False, error=f"Workspace '{key}' not found.")
+        return ToolResult(
+            ok=True,
+            data={"workspace_id": key, "api_calls": 42, "storage_mb": 128},
+        )
+
+    async def _get_subscription(self, workspace_id: str) -> ToolResult:
+        key = workspace_id.strip().lower()
+        if key not in _MockStore.workspaces and key != "demo":
+            return ToolResult(ok=False, error=f"Workspace '{key}' not found.")
+        return ToolResult(
+            ok=True,
+            data={"workspace_id": key, "plan": "pro", "status": "active"},
+        )
+
     async def _provision_link(
         self,
         site_a: str,

{api_operator-0.9.0 → api_operator-0.10.0}/api_operator/adapters/yaml_adapter.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import re
 from typing import Any
+from urllib.parse import urlparse, urlunparse
 
 import httpx
 
@@ -28,6 +29,7 @@ class YamlAdapter(Adapter):
         config_path: str,
         token: str | None = None,
         base_url: str | None = None,
+        connect_host: str | None = None,
     ) -> None:
         self.spec = load_adapter_spec(config_path)
         self.name = self.spec.name
@@ -35,6 +37,7 @@ class YamlAdapter(Adapter):
         self.token = token or _token_from_env(self.spec.token_env)
         if base_url:
             self.spec.base_url = base_url.rstrip("/")
+        self.connect_host = connect_host or self.spec.connect_host
 
     def auth_context(self) -> dict[str, Any]:
         return {"token": "***" if self.token else None, "base_url": self.spec.base_url}
@@ -87,11 +90,13 @@ class YamlAdapter(Adapter):
         if self.token and self.spec.auth_type == "bearer":
             headers[self.spec.auth_header] = f"Bearer {self.token}"
 
+        request_url, headers = _apply_connect_host(url, self.connect_host, headers)
+
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 response = await client.request(
                     spec.method,
-                    url,
+                    request_url,
                     headers=headers,
                     json=json_body,
                     params=params,
@@ -173,3 +178,34 @@ def _token_from_env(env_name: str | None) -> str | None:
     if not env_name:
         return None
     return os.environ.get(env_name)
+
+
+def _apply_connect_host(
+    url: str,
+    connect_host: str | None,
+    headers: dict[str, str],
+) -> tuple[str, dict[str, str]]:
+    if not connect_host:
+        return url, headers
+
+    parsed = urlparse(url)
+    if not parsed.hostname:
+        return url, headers
+
+    host_header = parsed.hostname
+    if parsed.port:
+        host_header = f"{host_header}:{parsed.port}"
+
+    headers = dict(headers)
+    headers["Host"] = host_header
+    request_url = urlunparse(
+        (
+            parsed.scheme,
+            connect_host,
+            parsed.path,
+            parsed.params,
+            parsed.query,
+            parsed.fragment,
+        )
+    )
+    return request_url, headers

{api_operator-0.9.0 → api_operator-0.10.0}/api_operator/adapters/yaml_spec.py

@@ -39,6 +39,7 @@ class AdapterSpec:
     auth_type: str = "bearer"
     auth_header: str = "Authorization"
     token_env: str | None = None
+    connect_host: str | None = None
 
 
 def load_adapter_spec(path: str | Path) -> AdapterSpec:
@@ -84,6 +85,7 @@ def load_adapter_spec(path: str | Path) -> AdapterSpec:
             )
         )
 
+    connect_host = raw.get("connect_host")
     return AdapterSpec(
         name=str(raw.get("name", file_path.stem)),
         description=str(raw.get("description", "")),
@@ -93,6 +95,7 @@ def load_adapter_spec(path: str | Path) -> AdapterSpec:
         auth_type=str(auth.get("type", "bearer")),
         auth_header=str(auth.get("header", "Authorization")),
         token_env=auth.get("env_token"),
+        connect_host=str(connect_host).strip() if connect_host else None,
     )
 
 

{api_operator-0.9.0 → api_operator-0.10.0}/api_operator/core/agent.py

@@ -6,6 +6,7 @@ from typing import Any
 from api_operator.adapters.base import Adapter
 from api_operator.core.config import Settings
 from api_operator.core.executor import ToolExecutor
+from api_operator.core.formatters import format_tool_success
 from api_operator.core.guardrails import Guardrails
 from api_operator.core.memory import Session, SessionStore
 from api_operator.core.planner import Planner
@@ -136,7 +137,7 @@ class Agent:
 
         payload = result.to_dict() if result else {"ok": False}
         if payload.get("ok"):
-            reply = f"{tool_name} succeeded: {payload.get('data')}"
+            reply = format_tool_success(tool_name, payload.get("data") or {})
             session.add("assistant", reply, status="ok", tool=tool_name)
             return AgentResponse(
                 session_id=session.id,

{api_operator-0.9.0 → api_operator-0.10.0}/api_operator/core/config.py

@@ -16,3 +16,4 @@ class Settings(BaseSettings):
     openai_model: str = "gpt-4o-mini"
     require_confirm_dangerous: bool = True
     log_tool_calls: bool = True
+    cors_origins: str = ""  # comma-separated origins; empty disables CORS middleware

api_operator-0.10.0/api_operator/core/formatters.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def format_tool_success(tool_name: str, data: Any) -> str:
+    if not isinstance(data, dict):
+        return f"{tool_name.replace('_', ' ')} completed successfully."
+
+    formatters = {
+        "list_workspaces": _format_list_workspaces,
+        "create_workspace": _format_create_workspace,
+        "get_usage": _format_get_usage,
+        "get_subscription": _format_get_subscription,
+        "invite_member": _format_invite,
+        "invite_team_member": _format_invite,
+        "list_connections": _format_list_connections,
+        "provision_link": _format_provision_link,
+    }
+    formatter = formatters.get(tool_name)
+    if formatter is not None:
+        return formatter(data)
+
+    return _format_generic(tool_name, data)
+
+
+def _workspace_items(data: dict[str, Any]) -> list[dict[str, Any]]:
+    payload = data.get("data", data)
+    if isinstance(payload, list):
+        return [item for item in payload if isinstance(item, dict)]
+    if isinstance(payload, dict):
+        nested = payload.get("workspaces")
+        if isinstance(nested, list):
+            return [item for item in nested if isinstance(item, dict)]
+        if any(key in payload for key in ("id", "name", "subdomain")):
+            return [payload]
+    nested = data.get("workspaces")
+    if isinstance(nested, list):
+        return [item for item in nested if isinstance(item, dict)]
+    return []
+
+
+def _format_list_workspaces(data: dict[str, Any]) -> str:
+    items = _workspace_items(data)
+    if not items:
+        return "No workspaces found."
+
+    lines = [f"Found {len(items)} workspace(s):", ""]
+    for workspace in items:
+        name = workspace.get("name") or workspace.get("id") or "Unknown"
+        identifier = workspace.get("id") or workspace.get("subdomain") or "?"
+        line = f"• {name} ({identifier})"
+        url = workspace.get("url")
+        if url:
+            line += f"\n  {url}"
+        status_bits: list[str] = []
+        if workspace.get("suspended"):
+            status_bits.append("suspended")
+        if workspace.get("subscribed"):
+            status_bits.append("subscribed")
+        if status_bits:
+            line += f"\n  Status: {', '.join(status_bits)}"
+        lines.append(line)
+
+    return "\n".join(lines)
+
+
+def _format_create_workspace(data: dict[str, Any]) -> str:
+    workspace = data.get("data", data)
+    if not isinstance(workspace, dict):
+        return "Workspace created successfully."
+
+    name = workspace.get("name") or workspace.get("id") or "Workspace"
+    identifier = workspace.get("id") or workspace.get("subdomain") or "?"
+    lines = [f"Workspace created: {name} ({identifier})"]
+    url = workspace.get("url")
+    if url:
+        lines.append(url)
+    return "\n".join(lines)
+
+
+def _format_get_usage(data: dict[str, Any]) -> str:
+    payload = data.get("data", data)
+    if not isinstance(payload, dict):
+        return "Usage retrieved."
+
+    workspace_id = payload.get("workspace_id", "workspace")
+    lines = [f"Usage for {workspace_id}:"]
+    for key, value in payload.items():
+        if key == "workspace_id":
+            continue
+        label = key.replace("_", " ").strip()
+        lines.append(f"• {label}: {value}")
+    return "\n".join(lines)
+
+
+def _format_get_subscription(data: dict[str, Any]) -> str:
+    payload = data.get("data", data)
+    if not isinstance(payload, dict):
+        return "Subscription retrieved."
+
+    workspace_id = payload.get("workspace_id", "workspace")
+    plan = payload.get("plan", "unknown")
+    status = payload.get("status", "unknown")
+    return f"Subscription for {workspace_id}: {plan} ({status})"
+
+
+def _format_invite(data: dict[str, Any]) -> str:
+    payload = data.get("data", data)
+    if not isinstance(payload, dict):
+        return "Invitation sent."
+
+    email = payload.get("email", "member")
+    workspace = payload.get("workspace") or payload.get("subdomain") or "workspace"
+    role = payload.get("role")
+    line = f"Invitation sent to {email} for {workspace}"
+    if role:
+        line += f" as {role}"
+    return f"{line}."
+
+
+def _format_list_connections(data: dict[str, Any]) -> str:
+    payload = data.get("data", data)
+    items: list[Any]
+    if isinstance(payload, dict):
+        nested = payload.get("connections")
+        items = nested if isinstance(nested, list) else []
+    elif isinstance(payload, list):
+        items = payload
+    else:
+        items = []
+
+    if not items:
+        return "No connections found."
+
+    lines = [f"Found {len(items)} connection(s):", ""]
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        site_a = item.get("site_a", "?")
+        site_b = item.get("site_b", "?")
+        bandwidth = item.get("bandwidth_mbps")
+        line = f"• {site_a} ↔ {site_b}"
+        if bandwidth is not None:
+            line += f" ({bandwidth} Mbps)"
+        lines.append(line)
+
+    return "\n".join(lines)
+
+
+def _format_provision_link(data: dict[str, Any]) -> str:
+    payload = data.get("data", data)
+    if not isinstance(payload, dict):
+        return "Link provisioned successfully."
+
+    site_a = payload.get("site_a", "?")
+    site_b = payload.get("site_b", "?")
+    bandwidth = payload.get("bandwidth_mbps")
+    line = f"Link provisioned: {site_a} ↔ {site_b}"
+    if bandwidth is not None:
+        line += f" at {bandwidth} Mbps"
+    return line
+
+
+def _format_generic(tool_name: str, data: dict[str, Any]) -> str:
+    label = tool_name.replace("_", " ")
+    if data.get("message") and len(data) == 1:
+        return str(data["message"])
+    return f"{label} completed successfully."

{api_operator-0.9.0 → api_operator-0.10.0}/api_operator/core/planner.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 from typing import Any, Protocol
 
@@ -38,13 +39,12 @@ class MockPlanner:
         lower = text.lower()
 
         if "help" in lower or "مساعدة" in text or lower.strip() == "tools":
-            names = ", ".join(registry.names())
             return PlanStep(
                 type="respond",
                 content=(
-                    "I can run these tools: "
-                    f"{names}. Try: 'list workspaces', 'create workspace Acme subdomain acme', "
-                    "'invite admin@acme.com to acme', 'provision link Riyadh Jeddah 500'."
+                    "I'm your Tenant Kit assistant. I can help with workspaces "
+                    "(list, create), billing (usage, subscription), and team invites. "
+                    "Use the chat menu buttons for a guided step-by-step flow."
                 ),
             )
 
@@ -83,6 +83,22 @@ class MockPlanner:
             if args.get("site_a") and args.get("site_b") and registry.get("provision_link"):
                 return PlanStep(type="tool", tool_name="provision_link", tool_args=args)
 
+        if _wants_get_subscription(lower, text) and registry.get("get_subscription"):
+            workspace_id = _extract_workspace_id(text) or "demo"
+            return PlanStep(
+                type="tool",
+                tool_name="get_subscription",
+                tool_args={"workspace_id": workspace_id},
+            )
+
+        if _wants_get_usage(lower, text) and registry.get("get_usage"):
+            workspace_id = _extract_workspace_id(text) or "demo"
+            return PlanStep(
+                type="tool",
+                tool_name="get_usage",
+                tool_args={"workspace_id": workspace_id},
+            )
+
         if _wants_list_connections(lower, text) and registry.get("list_connections"):
             return PlanStep(type="tool", tool_name="list_connections", tool_args={})
 
@@ -102,8 +118,10 @@ def _wants_create_workspace(lower: str) -> bool:
     return (
         "create workspace" in lower
         or "new workspace" in lower
+        or "add workspace" in lower
         or "أنشئ workspace" in lower
         or "انشئ workspace" in lower
+        or bool(re.search(r"\b(create|add|new)\b.*\bworkspace", lower))
     )
 
 
@@ -122,21 +140,62 @@ def _wants_list_connections(lower: str, text: str) -> bool:
 
 
 def _wants_list_workspaces(lower: str, text: str) -> bool:
-    if "workspace" not in lower and "workspace" not in text:
-        return False
     if _wants_create_workspace(lower):
         return False
+    if "workspace" not in lower and "workspace" not in text and "مساح" not in text:
+        return False
+    if re.search(r"\b(usage|subscription|invite)\b", lower):
+        return False
     return (
         "list workspace" in lower
         or "list workspaces" in lower
+        or "list of workspace" in lower
         or "show workspace" in lower
         or "show workspaces" in lower
+        or "show me workspace" in lower
+        or "get workspace" in lower
+        or "get workspaces" in lower
+        or "what workspace" in lower
+        or "which workspace" in lower
         or lower.strip() == "workspaces"
         or "ورّيني" in text
         or "اعرض" in text
+        or bool(re.search(r"\b(list|show|get|display|what|which|all)\b.*\bworkspaces?\b", lower))
+        or bool(re.search(r"\bworkspaces?\b.*\b(list|show|all)\b", lower))
+        or bool(re.search(r"\bi want\b.*\bworkspaces?\b", lower))
     )
 
 
+def _wants_get_usage(lower: str, text: str) -> bool:
+    return "usage" in lower or "استخدام" in text or "الاستخدام" in text
+
+
+def _wants_get_subscription(lower: str, text: str) -> bool:
+    return (
+        "subscription" in lower
+        or "subscribe" in lower
+        or "اشتراك" in text
+        or "الاشتراك" in text
+    )
+
+
+def _extract_workspace_id(text: str) -> str | None:
+    lower = text.lower()
+    for token in ("for ", "workspace "):
+        if token in lower:
+            segment = lower.split(token, 1)[1].strip().split()
+            if segment:
+                candidate = segment[0].strip(".,?!")
+                if candidate and candidate not in {"a", "the", "my"}:
+                    return candidate
+    match = re.search(r"\b([a-z0-9][a-z0-9-]{1,62})\b", lower)
+    if match and match.group(1) not in {"demo", "usage", "subscription", "for", "get"}:
+        return match.group(1)
+    if "demo" in lower:
+        return "demo"
+    return None
+
+
 def _extract_workspace_args(text: str) -> dict[str, Any]:
     args: dict[str, Any] = {}
     lower = text.lower()

{api_operator-0.9.0 → api_operator-0.10.0}/api_operator/server/app.py

@@ -32,15 +32,26 @@ class ChatResponse(BaseModel):
 
 def create_app(settings: Settings | None = None):
     from fastapi import FastAPI, HTTPException
+    from fastapi.middleware.cors import CORSMiddleware
 
     settings = settings or Settings()
     session_store = SessionStore()
     app = FastAPI(
         title="API Operator",
-        version="0.1.0",
+        version="0.10.0",
         description="Standalone AI operator with pluggable adapters",
     )
 
+    origins = [o.strip() for o in settings.cors_origins.split(",") if o.strip()]
+    if origins:
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=origins,
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
     @app.get("/health")
     async def health() -> dict[str, str]:
         return {"status": "ok", "adapter_default": settings.default_adapter}

{api_operator-0.9.0 → api_operator-0.10.0}/examples/tenant-kit-adapter/adapter.yaml

@@ -57,6 +57,16 @@ tools:
         type: string
         required: true
 
+  - name: get_usage
+    description: Get current billing period usage meters for a workspace
+    method: GET
+    path: /api/workspaces/{workspace_id}/usage
+    requires_ability: workspaces:read
+    parameters:
+      workspace_id:
+        type: string
+        required: true
+
   - name: invite_team_member
     description: Invite a member on the tenant subdomain API
     method: POST

{api_operator-0.9.0 → api_operator-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "api-operator"
-version = "0.9.0"
+version = "0.10.0"
 description = "Standalone AI API Operator with pluggable adapters for multi-project APIs"
 readme = "README.md"
 requires-python = ">=3.11"

{api_operator-0.9.0 → api_operator-0.10.0}/tests/test_api.py

@@ -50,7 +50,7 @@ async def test_tools_endpoint_mock(app):
     async with AsyncClient(transport=transport, base_url="http://test") as client:
         response = await client.get("/v1/tools?adapter=mock")
     assert response.status_code == 200
-    assert len(response.json()["tools"]) == 5
+    assert len(response.json()["tools"]) == 7
 
 
 @pytest.mark.asyncio

{api_operator-0.9.0 → api_operator-0.10.0}/tests/test_cli.py

@@ -13,7 +13,7 @@ def test_cli_demo():
     reset_mock_store()
     result = runner.invoke(app, ["demo"])
     assert result.exit_code == 0
-    assert "list_workspaces succeeded" in result.stdout
+    assert "Found" in result.stdout or "No workspaces found" in result.stdout
     assert "Demo complete" in result.stdout
 
 

{api_operator-0.9.0 → api_operator-0.10.0}/tests/test_core.py

@@ -129,6 +129,30 @@ async def test_mock_planner_routes():
     assert step.tool_name == "provision_link"
 
 
+@pytest.mark.asyncio
+async def test_mock_planner_natural_language():
+    from api_operator.adapters.mock import MockAdapter
+
+    planner = MockPlanner()
+    registry = MockAdapter().build_registry()
+
+    for phrase in (
+        "i want list of workspaces?",
+        "show me all workspaces",
+        "what workspaces do I have",
+    ):
+        step = await planner.plan(phrase, registry, [], "")
+        assert step.type == "tool" and step.tool_name == "list_workspaces", phrase
+
+    step = await planner.plan("get usage for demo", registry, [], "")
+    assert step.tool_name == "get_usage"
+    assert step.tool_args["workspace_id"] == "demo"
+
+    step = await planner.plan("subscription for demo", registry, [], "")
+    assert step.tool_name == "get_subscription"
+    assert step.tool_args["workspace_id"] == "demo"
+
+
 def test_tool_parameters_schema():
     schema = tool_parameters_schema({"name": str, "count": int}, ["name"])
     assert schema["properties"]["name"]["type"] == "string"

api_operator-0.10.0/tests/test_formatters.py

@@ -0,0 +1,36 @@
+from api_operator.core.formatters import format_tool_success
+
+
+def test_format_list_workspaces_from_api_payload():
+    message = format_tool_success(
+        "list_workspaces",
+        {
+            "data": [
+                {
+                    "id": "demo",
+                    "name": "Demo Workspace",
+                    "url": "http://demo.test",
+                    "suspended": False,
+                }
+            ]
+        },
+    )
+
+    assert "Found 1 workspace(s)" in message
+    assert "Demo Workspace (demo)" in message
+    assert "http://demo.test" in message
+    assert "{" not in message
+
+
+def test_format_list_workspaces_empty():
+    message = format_tool_success("list_workspaces", {"workspaces": [], "count": 0})
+    assert message == "No workspaces found."
+
+
+def test_format_create_workspace():
+    message = format_tool_success(
+        "create_workspace",
+        {"id": "acme", "name": "Acme", "url": "http://acme.test"},
+    )
+    assert "Workspace created: Acme (acme)" in message
+    assert "http://acme.test" in message

{api_operator-0.9.0 → api_operator-0.10.0}/tests/test_mock_adapter.py

@@ -22,7 +22,7 @@ def test_available_adapters_includes_mock_and_yaml():
 def test_load_mock_adapter():
     adapter = load_adapter("mock")
     assert adapter.name == "mock"
-    assert len(adapter.build_registry().list_tools()) == 5
+    assert len(adapter.build_registry().list_tools()) == 7
 
 
 def test_load_yaml_requires_config():

{api_operator-0.9.0 → api_operator-0.10.0}/tests/test_scenarios_e2e.py

@@ -90,7 +90,8 @@ async def test_help_lists_tools():
     agent = build_agent("mock", settings=Settings(planner="mock"))
     response = await agent.chat("help")
     assert response.status == "ok"
-    assert "create_workspace" in response.message or "list workspaces" in response.message.lower()
+    assert "workspaces" in response.message.lower()
+    assert "assistant" in response.message.lower()
 
 
 @pytest.mark.asyncio

{api_operator-0.9.0 → api_operator-0.10.0}/tests/test_yaml_adapter.py

@@ -60,6 +60,40 @@ async def test_yaml_tenant_host_url(tmp_path, monkeypatch):
     assert captured["url"] == "http://acme.app.test/api/team/invitations"
 
 
+@pytest.mark.asyncio
+async def test_yaml_connect_host_routes_via_internal_nginx(tmp_path, monkeypatch):
+    path = tmp_path / "c.yaml"
+    path.write_text(
+        "name: x\nbase_url: http://app.test\ntools:\n  - name: t\n    method: GET\n    path: /api/workspaces\n",
+        encoding="utf-8",
+    )
+    adapter = YamlAdapter(config_path=str(path), token="tok", connect_host="nginx")
+    spec = adapter.spec.tools[0]
+
+    captured: dict[str, object] = {}
+
+    class FakeResponse:
+        status_code = 200
+        text = ""
+        def json(self): return {"data": []}
+        @property
+        def is_success(self): return True
+
+    class FakeClient:
+        async def __aenter__(self): return self
+        async def __aexit__(self, *a): pass
+        async def request(self, method, url, **kwargs):
+            captured["url"] = url
+            captured["headers"] = kwargs.get("headers", {})
+            return FakeResponse()
+
+    monkeypatch.setattr("api_operator.adapters.yaml_adapter.httpx.AsyncClient", lambda **k: FakeClient())
+    result = await adapter._execute(spec, {})
+    assert result.ok
+    assert captured["url"] == "http://nginx/api/workspaces"
+    assert captured["headers"]["Host"] == "app.test"
+
+
 @pytest.mark.asyncio
 async def test_yaml_missing_token(tmp_path):
     path = tmp_path / "a.yaml"
@@ -182,4 +216,5 @@ tools:
     agent = build_agent("yaml", config_path=str(yaml_path), token="t", settings=Settings(planner="mock"))
     response = await agent.chat("list workspaces", abilities=["workspaces:read"])
     assert response.status == "ok"
-    assert "list_workspaces" in response.message
+    assert "Found 1 workspace" in response.message
+    assert response.tool == "list_workspaces"