Adopt shared response parser across remaining managers

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

Author: cursoragent

hyperbrowser/client/managers/async_manager/agents/browser_use.py

@@ -3,6 +3,7 @@
 from hyperbrowser.exceptions import HyperbrowserError
 from ....polling import build_operation_name, wait_for_job_result_async
 from ....schema_utils import resolve_schema_input
+from ...response_utils import parse_response_model
 
 from .....models import (
     POLLING_ATTEMPTS,
@@ -30,25 +31,41 @@ async def start(
             self._client._build_url("/task/browser-use"),
             data=payload,
         )
-        return StartBrowserUseTaskResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=StartBrowserUseTaskResponse,
+            operation_name="browser-use start",
+        )
 
     async def get(self, job_id: str) -> BrowserUseTaskResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/task/browser-use/{job_id}")
         )
-        return BrowserUseTaskResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=BrowserUseTaskResponse,
+            operation_name="browser-use task",
+        )
 
     async def get_status(self, job_id: str) -> BrowserUseTaskStatusResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/task/browser-use/{job_id}/status")
         )
-        return BrowserUseTaskStatusResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=BrowserUseTaskStatusResponse,
+            operation_name="browser-use task status",
+        )
 
     async def stop(self, job_id: str) -> BasicResponse:
         response = await self._client.transport.put(
             self._client._build_url(f"/task/browser-use/{job_id}/stop")
         )
-        return BasicResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=BasicResponse,
+            operation_name="browser-use task stop",
+        )
 
     async def start_and_wait(
         self,

hyperbrowser/client/managers/async_manager/agents/claude_computer_use.py

@@ -2,6 +2,7 @@
 
 from hyperbrowser.exceptions import HyperbrowserError
 from ....polling import build_operation_name, wait_for_job_result_async
+from ...response_utils import parse_response_model
 
 from .....models import (
     POLLING_ATTEMPTS,
@@ -24,25 +25,41 @@ async def start(
             self._client._build_url("/task/claude-computer-use"),
             data=params.model_dump(exclude_none=True, by_alias=True),
         )
-        return StartClaudeComputerUseTaskResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=StartClaudeComputerUseTaskResponse,
+            operation_name="claude computer use start",
+        )
 
     async def get(self, job_id: str) -> ClaudeComputerUseTaskResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/task/claude-computer-use/{job_id}")
         )
-        return ClaudeComputerUseTaskResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=ClaudeComputerUseTaskResponse,
+            operation_name="claude computer use task",
+        )
 
     async def get_status(self, job_id: str) -> ClaudeComputerUseTaskStatusResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/task/claude-computer-use/{job_id}/status")
         )
-        return ClaudeComputerUseTaskStatusResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=ClaudeComputerUseTaskStatusResponse,
+            operation_name="claude computer use task status",
+        )
 
     async def stop(self, job_id: str) -> BasicResponse:
         response = await self._client.transport.put(
             self._client._build_url(f"/task/claude-computer-use/{job_id}/stop")
         )
-        return BasicResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=BasicResponse,
+            operation_name="claude computer use task stop",
+        )
 
     async def start_and_wait(
         self,

hyperbrowser/client/managers/async_manager/agents/cua.py

@@ -2,6 +2,7 @@
 
 from hyperbrowser.exceptions import HyperbrowserError
 from ....polling import build_operation_name, wait_for_job_result_async
+from ...response_utils import parse_response_model
 
 from .....models import (
     POLLING_ATTEMPTS,
@@ -22,25 +23,41 @@ async def start(self, params: StartCuaTaskParams) -> StartCuaTaskResponse:
             self._client._build_url("/task/cua"),
             data=params.model_dump(exclude_none=True, by_alias=True),
         )
-        return StartCuaTaskResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=StartCuaTaskResponse,
+            operation_name="cua start",
+        )
 
     async def get(self, job_id: str) -> CuaTaskResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/task/cua/{job_id}")
         )
-        return CuaTaskResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=CuaTaskResponse,
+            operation_name="cua task",
+        )
 
     async def get_status(self, job_id: str) -> CuaTaskStatusResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/task/cua/{job_id}/status")
         )
-        return CuaTaskStatusResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=CuaTaskStatusResponse,
+            operation_name="cua task status",
+        )
 
     async def stop(self, job_id: str) -> BasicResponse:
         response = await self._client.transport.put(
             self._client._build_url(f"/task/cua/{job_id}/stop")
         )
-        return BasicResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=BasicResponse,
+            operation_name="cua task stop",
+        )
 
     async def start_and_wait(
         self,

hyperbrowser/client/managers/async_manager/agents/gemini_computer_use.py

@@ -2,6 +2,7 @@
 
 from hyperbrowser.exceptions import HyperbrowserError
 from ....polling import build_operation_name, wait_for_job_result_async
+from ...response_utils import parse_response_model
 
 from .....models import (
     POLLING_ATTEMPTS,
@@ -24,25 +25,41 @@ async def start(
             self._client._build_url("/task/gemini-computer-use"),
             data=params.model_dump(exclude_none=True, by_alias=True),
         )
-        return StartGeminiComputerUseTaskResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=StartGeminiComputerUseTaskResponse,
+            operation_name="gemini computer use start",
+        )
 
     async def get(self, job_id: str) -> GeminiComputerUseTaskResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/task/gemini-computer-use/{job_id}")
         )
-        return GeminiComputerUseTaskResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=GeminiComputerUseTaskResponse,
+            operation_name="gemini computer use task",
+        )
 
     async def get_status(self, job_id: str) -> GeminiComputerUseTaskStatusResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/task/gemini-computer-use/{job_id}/status")
         )
-        return GeminiComputerUseTaskStatusResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=GeminiComputerUseTaskStatusResponse,
+            operation_name="gemini computer use task status",
+        )
 
     async def stop(self, job_id: str) -> BasicResponse:
         response = await self._client.transport.put(
             self._client._build_url(f"/task/gemini-computer-use/{job_id}/stop")
         )
-        return BasicResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=BasicResponse,
+            operation_name="gemini computer use task stop",
+        )
 
     async def start_and_wait(
         self,

hyperbrowser/client/managers/async_manager/agents/hyper_agent.py

@@ -2,6 +2,7 @@
 
 from hyperbrowser.exceptions import HyperbrowserError
 from ....polling import build_operation_name, wait_for_job_result_async
+from ...response_utils import parse_response_model
 
 from .....models import (
     POLLING_ATTEMPTS,
@@ -24,25 +25,41 @@ async def start(
             self._client._build_url("/task/hyper-agent"),
             data=params.model_dump(exclude_none=True, by_alias=True),
         )
-        return StartHyperAgentTaskResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=StartHyperAgentTaskResponse,
+            operation_name="hyper agent start",
+        )
 
     async def get(self, job_id: str) -> HyperAgentTaskResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/task/hyper-agent/{job_id}")
         )
-        return HyperAgentTaskResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=HyperAgentTaskResponse,
+            operation_name="hyper agent task",
+        )
 
     async def get_status(self, job_id: str) -> HyperAgentTaskStatusResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/task/hyper-agent/{job_id}/status")
         )
-        return HyperAgentTaskStatusResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=HyperAgentTaskStatusResponse,
+            operation_name="hyper agent task status",
+        )
 
     async def stop(self, job_id: str) -> BasicResponse:
         response = await self._client.transport.put(
             self._client._build_url(f"/task/hyper-agent/{job_id}/stop")
         )
-        return BasicResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=BasicResponse,
+            operation_name="hyper agent task stop",
+        )
 
     async def start_and_wait(
         self,

hyperbrowser/client/managers/async_manager/crawl.py

@@ -8,6 +8,7 @@
     poll_until_terminal_status_async,
     retry_operation_async,
 )
+from ..response_utils import parse_response_model
 from ....models.crawl import (
     CrawlJobResponse,
     CrawlJobStatusResponse,
@@ -27,13 +28,21 @@ async def start(self, params: StartCrawlJobParams) -> StartCrawlJobResponse:
             self._client._build_url("/crawl"),
             data=params.model_dump(exclude_none=True, by_alias=True),
         )
-        return StartCrawlJobResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=StartCrawlJobResponse,
+            operation_name="crawl start",
+        )
 
     async def get_status(self, job_id: str) -> CrawlJobStatusResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/crawl/{job_id}/status")
         )
-        return CrawlJobStatusResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=CrawlJobStatusResponse,
+            operation_name="crawl status",
+        )
 
     async def get(
         self, job_id: str, params: Optional[GetCrawlJobParams] = None
@@ -43,7 +52,11 @@ async def get(
             self._client._build_url(f"/crawl/{job_id}"),
             params=params_obj.model_dump(exclude_none=True, by_alias=True),
         )
-        return CrawlJobResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=CrawlJobResponse,
+            operation_name="crawl job",
+        )
 
     async def start_and_wait(
         self,

hyperbrowser/client/managers/async_manager/extension.py

@@ -3,6 +3,7 @@
 from hyperbrowser.exceptions import HyperbrowserError
 from ...file_utils import ensure_existing_file_path
 from ..extension_utils import parse_extension_list_response_data
+from ..response_utils import parse_response_model
 from hyperbrowser.models.extension import CreateExtensionParams, ExtensionResponse
 
 
@@ -35,7 +36,11 @@ async def create(self, params: CreateExtensionParams) -> ExtensionResponse:
                 f"Failed to open extension file at path: {file_path}",
                 original_error=exc,
             ) from exc
-        return ExtensionResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=ExtensionResponse,
+            operation_name="create extension",
+        )
 
     async def list(self) -> List[ExtensionResponse]:
         response = await self._client.transport.get(

hyperbrowser/client/managers/async_manager/extract.py

@@ -10,6 +10,7 @@
 )
 from ...polling import build_operation_name, wait_for_job_result_async
 from ...schema_utils import resolve_schema_input
+from ..response_utils import parse_response_model
 
 
 class ExtractManager:
@@ -28,19 +29,31 @@ async def start(self, params: StartExtractJobParams) -> StartExtractJobResponse:
             self._client._build_url("/extract"),
             data=payload,
         )
-        return StartExtractJobResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=StartExtractJobResponse,
+            operation_name="extract start",
+        )
 
     async def get_status(self, job_id: str) -> ExtractJobStatusResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/extract/{job_id}/status")
         )
-        return ExtractJobStatusResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=ExtractJobStatusResponse,
+            operation_name="extract status",
+        )
 
     async def get(self, job_id: str) -> ExtractJobResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/extract/{job_id}")
         )
-        return ExtractJobResponse(**response.data)
+        return parse_response_model(
+            response.data,
+            model=ExtractJobResponse,
+            operation_name="extract job",
+        )
 
     async def start_and_wait(
         self,