Reuse job request helpers across agent utilities

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

hyperbrowser/client/managers/agent_start_utils.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, Type, TypeVar
 
-from .response_utils import parse_response_model
+from .job_request_utils import start_job, start_job_async
 
 T = TypeVar("T")
 
@@ -13,12 +13,10 @@ def start_agent_task(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = client.transport.post(
-        client._build_url(route_prefix),
-        data=payload,
-    )
-    return parse_response_model(
-        response.data,
+    return start_job(
+        client=client,
+        route_prefix=route_prefix,
+        payload=payload,
         model=model,
         operation_name=operation_name,
     )
@@ -32,12 +30,10 @@ async def start_agent_task_async(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = await client.transport.post(
-        client._build_url(route_prefix),
-        data=payload,
-    )
-    return parse_response_model(
-        response.data,
+    return await start_job_async(
+        client=client,
+        route_prefix=route_prefix,
+        payload=payload,
         model=model,
         operation_name=operation_name,
     )

hyperbrowser/client/managers/agent_stop_utils.py

@@ -2,8 +2,7 @@
 
 from hyperbrowser.models import BasicResponse
 
-from .job_route_builders import build_job_action_route
-from .response_utils import parse_response_model
+from .job_request_utils import put_job_action, put_job_action_async
 
 
 def stop_agent_task(
@@ -13,13 +12,11 @@ def stop_agent_task(
     job_id: str,
     operation_name: str,
 ) -> BasicResponse:
-    response = client.transport.put(
-        client._build_url(
-            build_job_action_route(route_prefix, job_id, "/stop"),
-        ),
-    )
-    return parse_response_model(
-        response.data,
+    return put_job_action(
+        client=client,
+        route_prefix=route_prefix,
+        job_id=job_id,
+        action_suffix="/stop",
         model=BasicResponse,
         operation_name=operation_name,
     )
@@ -32,13 +29,11 @@ async def stop_agent_task_async(
     job_id: str,
     operation_name: str,
 ) -> BasicResponse:
-    response = await client.transport.put(
-        client._build_url(
-            build_job_action_route(route_prefix, job_id, "/stop"),
-        ),
-    )
-    return parse_response_model(
-        response.data,
+    return await put_job_action_async(
+        client=client,
+        route_prefix=route_prefix,
+        job_id=job_id,
+        action_suffix="/stop",
         model=BasicResponse,
         operation_name=operation_name,
     )

hyperbrowser/client/managers/agent_task_read_utils.py

@@ -1,7 +1,11 @@
 from typing import Any, Type, TypeVar
 
-from .job_route_builders import build_job_route, build_job_status_route
-from .response_utils import parse_response_model
+from .job_request_utils import (
+    get_job,
+    get_job_async,
+    get_job_status,
+    get_job_status_async,
+)
 
 T = TypeVar("T")
 
@@ -14,11 +18,11 @@ def get_agent_task(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = client.transport.get(
-        client._build_url(build_job_route(route_prefix, job_id)),
-    )
-    return parse_response_model(
-        response.data,
+    return get_job(
+        client=client,
+        route_prefix=route_prefix,
+        job_id=job_id,
+        params=None,
         model=model,
         operation_name=operation_name,
     )
@@ -32,11 +36,10 @@ def get_agent_task_status(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = client.transport.get(
-        client._build_url(build_job_status_route(route_prefix, job_id)),
-    )
-    return parse_response_model(
-        response.data,
+    return get_job_status(
+        client=client,
+        route_prefix=route_prefix,
+        job_id=job_id,
         model=model,
         operation_name=operation_name,
     )
@@ -50,11 +53,11 @@ async def get_agent_task_async(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = await client.transport.get(
-        client._build_url(build_job_route(route_prefix, job_id)),
-    )
-    return parse_response_model(
-        response.data,
+    return await get_job_async(
+        client=client,
+        route_prefix=route_prefix,
+        job_id=job_id,
+        params=None,
         model=model,
         operation_name=operation_name,
     )
@@ -68,11 +71,10 @@ async def get_agent_task_status_async(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = await client.transport.get(
-        client._build_url(build_job_status_route(route_prefix, job_id)),
-    )
-    return parse_response_model(
-        response.data,
+    return await get_job_status_async(
+        client=client,
+        route_prefix=route_prefix,
+        job_id=job_id,
         model=model,
         operation_name=operation_name,
     )

hyperbrowser/client/managers/job_request_utils.py

@@ -1,6 +1,10 @@
 from typing import Any, Dict, Optional, Type, TypeVar
 
-from .job_route_builders import build_job_route, build_job_status_route
+from .job_route_builders import (
+    build_job_action_route,
+    build_job_route,
+    build_job_status_route,
+)
 from .response_utils import parse_response_model
 
 T = TypeVar("T")
@@ -118,3 +122,41 @@ async def get_job_async(
         model=model,
         operation_name=operation_name,
     )
+
+
+def put_job_action(
+    *,
+    client: Any,
+    route_prefix: str,
+    job_id: str,
+    action_suffix: str,
+    model: Type[T],
+    operation_name: str,
+) -> T:
+    response = client.transport.put(
+        client._build_url(build_job_action_route(route_prefix, job_id, action_suffix)),
+    )
+    return parse_response_model(
+        response.data,
+        model=model,
+        operation_name=operation_name,
+    )
+
+
+async def put_job_action_async(
+    *,
+    client: Any,
+    route_prefix: str,
+    job_id: str,
+    action_suffix: str,
+    model: Type[T],
+    operation_name: str,
+) -> T:
+    response = await client.transport.put(
+        client._build_url(build_job_action_route(route_prefix, job_id, action_suffix)),
+    )
+    return parse_response_model(
+        response.data,
+        model=model,
+        operation_name=operation_name,
+    )

tests/test_agent_route_builder_usage.py

@@ -5,21 +5,21 @@
 pytestmark = pytest.mark.architecture
 
 
-def test_agent_task_read_helpers_use_shared_job_route_builders():
+def test_agent_task_read_helpers_reuse_job_request_helpers():
     module_text = Path(
         "hyperbrowser/client/managers/agent_task_read_utils.py"
     ).read_text(encoding="utf-8")
-    assert "job_route_builders import build_job_route, build_job_status_route" in module_text
-    assert "build_job_route(route_prefix, job_id)" in module_text
-    assert "build_job_status_route(route_prefix, job_id)" in module_text
-    assert 'f"{route_prefix}/{job_id}"' not in module_text
-    assert 'f"{route_prefix}/{job_id}/status"' not in module_text
+    assert "job_request_utils import" in module_text
+    assert "get_job(" in module_text
+    assert "get_job_status(" in module_text
+    assert "get_job_async(" in module_text
+    assert "get_job_status_async(" in module_text
 
 
-def test_agent_stop_helpers_use_shared_job_route_builders():
+def test_agent_stop_helpers_reuse_job_request_helpers():
     module_text = Path("hyperbrowser/client/managers/agent_stop_utils.py").read_text(
         encoding="utf-8"
     )
-    assert "job_route_builders import build_job_action_route" in module_text
-    assert 'build_job_action_route(route_prefix, job_id, "/stop")' in module_text
-    assert 'f"{route_prefix}/{job_id}/stop"' not in module_text
+    assert "job_request_utils import put_job_action, put_job_action_async" in module_text
+    assert "put_job_action(" in module_text
+    assert "put_job_action_async(" in module_text

tests/test_agent_start_utils.py

@@ -1,88 +1,57 @@
 import asyncio
-from types import SimpleNamespace
 
 import hyperbrowser.client.managers.agent_start_utils as agent_start_utils
 
 
-def test_start_agent_task_builds_start_url_and_parses_response():
+def test_start_agent_task_delegates_to_start_job():
     captured = {}
 
-    class _SyncTransport:
-        def post(self, url, data):
-            captured["url"] = url
-            captured["data"] = data
-            return SimpleNamespace(data={"id": "job-1"})
-
-    class _Client:
-        transport = _SyncTransport()
-
-        @staticmethod
-        def _build_url(path: str) -> str:
-            return f"https://api.example.test{path}"
-
-    def _fake_parse_response_model(data, **kwargs):
-        captured["parse_data"] = data
-        captured["parse_kwargs"] = kwargs
+    def _fake_start_job(**kwargs):
+        captured.update(kwargs)
         return {"parsed": True}
 
-    original_parse = agent_start_utils.parse_response_model
-    agent_start_utils.parse_response_model = _fake_parse_response_model
+    original_start_job = agent_start_utils.start_job
+    agent_start_utils.start_job = _fake_start_job
     try:
         result = agent_start_utils.start_agent_task(
-            client=_Client(),
+            client=object(),
             route_prefix="/task/cua",
             payload={"task": "open docs"},
             model=object,
             operation_name="cua start",
         )
     finally:
-        agent_start_utils.parse_response_model = original_parse
+        agent_start_utils.start_job = original_start_job
 
     assert result == {"parsed": True}
-    assert captured["url"] == "https://api.example.test/task/cua"
-    assert captured["data"] == {"task": "open docs"}
-    assert captured["parse_data"] == {"id": "job-1"}
-    assert captured["parse_kwargs"]["operation_name"] == "cua start"
+    assert captured["route_prefix"] == "/task/cua"
+    assert captured["payload"] == {"task": "open docs"}
+    assert captured["operation_name"] == "cua start"
 
 
-def test_start_agent_task_async_builds_start_url_and_parses_response():
+def test_start_agent_task_async_delegates_to_start_job_async():
     captured = {}
 
-    class _AsyncTransport:
-        async def post(self, url, data):
-            captured["url"] = url
-            captured["data"] = data
-            return SimpleNamespace(data={"id": "job-2"})
-
-    class _Client:
-        transport = _AsyncTransport()
-
-        @staticmethod
-        def _build_url(path: str) -> str:
-            return f"https://api.example.test{path}"
-
-    def _fake_parse_response_model(data, **kwargs):
-        captured["parse_data"] = data
-        captured["parse_kwargs"] = kwargs
+    async def _fake_start_job_async(**kwargs):
+        captured.update(kwargs)
         return {"parsed": True}
 
-    original_parse = agent_start_utils.parse_response_model
-    agent_start_utils.parse_response_model = _fake_parse_response_model
+    original_start_job_async = agent_start_utils.start_job_async
+    agent_start_utils.start_job_async = _fake_start_job_async
     try:
         result = asyncio.run(
             agent_start_utils.start_agent_task_async(
-                client=_Client(),
+                client=object(),
                 route_prefix="/task/browser-use",
                 payload={"task": "browse"},
                 model=object,
                 operation_name="browser-use start",
             )
         )
     finally:
-        agent_start_utils.parse_response_model = original_parse
+        agent_start_utils.start_job_async = original_start_job_async
 
     assert result == {"parsed": True}
-    assert captured["url"] == "https://api.example.test/task/browser-use"
-    assert captured["data"] == {"task": "browse"}
-    assert captured["parse_data"] == {"id": "job-2"}
-    assert captured["parse_kwargs"]["operation_name"] == "browser-use start"
+    assert captured["route_prefix"] == "/task/browser-use"
+    assert captured["payload"] == {"task": "browse"}
+    assert captured["operation_name"] == "browser-use start"