airbyte-agent-zendesk-support 0.18.47__py3-none-any.whl → 0.18.57__py3-none-any.whl

airbyte_agent_zendesk_support/__init__.py

@@ -72,7 +72,33 @@ from .models import (
     SlaPoliciesListResult,
     TicketFormsListResult,
     ArticlesListResult,
-    ArticleAttachmentsListResult
+    ArticleAttachmentsListResult,
+    AirbyteSearchHit,
+    AirbyteSearchResult,
+    BrandsSearchData,
+    BrandsSearchResult,
+    GroupsSearchData,
+    GroupsSearchResult,
+    OrganizationsSearchData,
+    OrganizationsSearchResult,
+    SatisfactionRatingsSearchData,
+    SatisfactionRatingsSearchResult,
+    TagsSearchData,
+    TagsSearchResult,
+    TicketAuditsSearchData,
+    TicketAuditsSearchResult,
+    TicketCommentsSearchData,
+    TicketCommentsSearchResult,
+    TicketFieldsSearchData,
+    TicketFieldsSearchResult,
+    TicketFormsSearchData,
+    TicketFormsSearchResult,
+    TicketMetricsSearchData,
+    TicketMetricsSearchResult,
+    TicketsSearchData,
+    TicketsSearchResult,
+    UsersSearchData,
+    UsersSearchResult
 )
 from .types import (
     TicketsListParams,
@@ -114,7 +140,45 @@ from .types import (
     ArticlesGetParams,
     ArticleAttachmentsListParams,
     ArticleAttachmentsGetParams,
-    ArticleAttachmentsDownloadParams
+    ArticleAttachmentsDownloadParams,
+    AirbyteSearchParams,
+    AirbyteSortOrder,
+    BrandsSearchFilter,
+    BrandsSearchQuery,
+    BrandsCondition,
+    GroupsSearchFilter,
+    GroupsSearchQuery,
+    GroupsCondition,
+    OrganizationsSearchFilter,
+    OrganizationsSearchQuery,
+    OrganizationsCondition,
+    SatisfactionRatingsSearchFilter,
+    SatisfactionRatingsSearchQuery,
+    SatisfactionRatingsCondition,
+    TagsSearchFilter,
+    TagsSearchQuery,
+    TagsCondition,
+    TicketAuditsSearchFilter,
+    TicketAuditsSearchQuery,
+    TicketAuditsCondition,
+    TicketCommentsSearchFilter,
+    TicketCommentsSearchQuery,
+    TicketCommentsCondition,
+    TicketFieldsSearchFilter,
+    TicketFieldsSearchQuery,
+    TicketFieldsCondition,
+    TicketFormsSearchFilter,
+    TicketFormsSearchQuery,
+    TicketFormsCondition,
+    TicketMetricsSearchFilter,
+    TicketMetricsSearchQuery,
+    TicketMetricsCondition,
+    TicketsSearchFilter,
+    TicketsSearchQuery,
+    TicketsCondition,
+    UsersSearchFilter,
+    UsersSearchQuery,
+    UsersCondition
 )
 
 __all__ = [
@@ -186,6 +250,32 @@ __all__ = [
     "TicketFormsListResult",
     "ArticlesListResult",
     "ArticleAttachmentsListResult",
+    "AirbyteSearchHit",
+    "AirbyteSearchResult",
+    "BrandsSearchData",
+    "BrandsSearchResult",
+    "GroupsSearchData",
+    "GroupsSearchResult",
+    "OrganizationsSearchData",
+    "OrganizationsSearchResult",
+    "SatisfactionRatingsSearchData",
+    "SatisfactionRatingsSearchResult",
+    "TagsSearchData",
+    "TagsSearchResult",
+    "TicketAuditsSearchData",
+    "TicketAuditsSearchResult",
+    "TicketCommentsSearchData",
+    "TicketCommentsSearchResult",
+    "TicketFieldsSearchData",
+    "TicketFieldsSearchResult",
+    "TicketFormsSearchData",
+    "TicketFormsSearchResult",
+    "TicketMetricsSearchData",
+    "TicketMetricsSearchResult",
+    "TicketsSearchData",
+    "TicketsSearchResult",
+    "UsersSearchData",
+    "UsersSearchResult",
     "TicketsListParams",
     "TicketsGetParams",
     "UsersListParams",
@@ -226,4 +316,42 @@ __all__ = [
     "ArticleAttachmentsListParams",
     "ArticleAttachmentsGetParams",
     "ArticleAttachmentsDownloadParams",
+    "AirbyteSearchParams",
+    "AirbyteSortOrder",
+    "BrandsSearchFilter",
+    "BrandsSearchQuery",
+    "BrandsCondition",
+    "GroupsSearchFilter",
+    "GroupsSearchQuery",
+    "GroupsCondition",
+    "OrganizationsSearchFilter",
+    "OrganizationsSearchQuery",
+    "OrganizationsCondition",
+    "SatisfactionRatingsSearchFilter",
+    "SatisfactionRatingsSearchQuery",
+    "SatisfactionRatingsCondition",
+    "TagsSearchFilter",
+    "TagsSearchQuery",
+    "TagsCondition",
+    "TicketAuditsSearchFilter",
+    "TicketAuditsSearchQuery",
+    "TicketAuditsCondition",
+    "TicketCommentsSearchFilter",
+    "TicketCommentsSearchQuery",
+    "TicketCommentsCondition",
+    "TicketFieldsSearchFilter",
+    "TicketFieldsSearchQuery",
+    "TicketFieldsCondition",
+    "TicketFormsSearchFilter",
+    "TicketFormsSearchQuery",
+    "TicketFormsCondition",
+    "TicketMetricsSearchFilter",
+    "TicketMetricsSearchQuery",
+    "TicketMetricsCondition",
+    "TicketsSearchFilter",
+    "TicketsSearchQuery",
+    "TicketsCondition",
+    "UsersSearchFilter",
+    "UsersSearchQuery",
+    "UsersCondition",
 ]

airbyte_agent_zendesk_support/_vendored/connector_sdk/auth_strategies.py

@@ -152,6 +152,11 @@ class OAuth2AuthConfig(TypedDict, total=False):
             Note: Any config key can be used as a template variable in refresh_url.
             Common patterns: subdomain (Zendesk), shop (Shopify), region (AWS-style APIs).
 
+        additional_headers: Extra headers to inject alongside the OAuth2 Bearer token.
+            Useful for APIs that require both OAuth and an API key/client ID header.
+            Values support Jinja2 {{ variable }} template syntax to reference secrets.
+            Example: {"Amazon-Advertising-API-ClientId": "{{ client_id }}"}
+
     Examples:
         GitHub (simple):
             {"header": "Authorization", "prefix": "Bearer"}
@@ -169,6 +174,14 @@ class OAuth2AuthConfig(TypedDict, total=False):
                 "auth_style": "basic",
                 "body_format": "json"
             }
+
+        Amazon Ads (OAuth + additional client ID header):
+            {
+                "refresh_url": "https://api.amazon.com/auth/o2/token",
+                "additional_headers": {
+                    "Amazon-Advertising-API-ClientId": "{{ client_id }}"
+                }
+            }
     """
 
     header: str
@@ -177,6 +190,7 @@ class OAuth2AuthConfig(TypedDict, total=False):
     auth_style: AuthStyle
     body_format: BodyFormat
     subdomain: str
+    additional_headers: dict[str, str]
 
 
 class OAuth2AuthSecrets(TypedDict):
@@ -552,9 +566,10 @@ class OAuth2AuthStrategy(AuthStrategy):
         config: OAuth2AuthConfig,
         secrets: OAuth2AuthSecrets,
     ) -> dict[str, str]:
-        """Inject OAuth2 access token into headers.
+        """Inject OAuth2 access token and additional headers.
 
-        Creates a copy of the headers dict with the OAuth2 token added.
+        Creates a copy of the headers dict with the OAuth2 token added,
+        plus any additional headers configured via additional_headers.
         The original headers dict is not modified.
 
         Args:
@@ -563,7 +578,7 @@ class OAuth2AuthStrategy(AuthStrategy):
             secrets: OAuth2 credentials including access_token
 
         Returns:
-            New headers dict with OAuth2 token authentication injected
+            New headers dict with OAuth2 token and additional headers injected
 
         Raises:
             AuthenticationError: If access_token is missing
@@ -589,8 +604,44 @@ class OAuth2AuthStrategy(AuthStrategy):
         # Extract secret value (handle both SecretStr and plain str)
         token_value = extract_secret_value(access_token)
 
-        # Inject into headers
+        # Inject OAuth2 Bearer token
         headers[header_name] = f"{prefix} {token_value}"
+
+        # Inject additional headers if configured
+        additional_headers = config.get("additional_headers")
+        if additional_headers:
+            headers = self._inject_additional_headers(headers, additional_headers, secrets)
+
+        return headers
+
+    def _inject_additional_headers(
+        self,
+        headers: dict[str, str],
+        additional_headers: dict[str, str],
+        secrets: dict[str, Any],
+    ) -> dict[str, str]:
+        """Inject additional headers with Jinja2 template variable substitution.
+
+        Processes additional_headers config, substituting {{ variable }} patterns
+        with values from secrets using Jinja2 templating.
+
+        Args:
+            headers: Headers dict to add to (modified in place)
+            additional_headers: Header name -> value template mapping
+            secrets: Secrets dict for variable substitution
+
+        Returns:
+            Headers dict with additional headers added
+        """
+        # Build template context with extracted secret values
+        template_context = {key: extract_secret_value(value) for key, value in secrets.items()}
+
+        for header_name, value_template in additional_headers.items():
+            # Use Jinja2 templating for variable substitution
+            template = Template(value_template)
+            header_value = template.render(**template_context)
+            headers[header_name] = header_value
+
         return headers
 
     def validate_credentials(self, secrets: OAuth2AuthSecrets) -> None:  # type: ignore[override]

airbyte_agent_zendesk_support/_vendored/connector_sdk/connector_model_loader.py

@@ -188,7 +188,7 @@ def parse_openapi_spec(raw_config: dict) -> OpenAPIConnector:
 
 def _extract_request_body_config(
     request_body: RequestBody | None, spec_dict: dict[str, Any]
-) -> tuple[list[str], dict[str, Any] | None, dict[str, Any] | None]:
+) -> tuple[list[str], dict[str, Any] | None, dict[str, Any] | None, dict[str, Any]]:
     """Extract request body configuration (GraphQL or standard).
 
     Args:
@@ -196,17 +196,19 @@ def _extract_request_body_config(
         spec_dict: Full OpenAPI spec dict for $ref resolution
 
     Returns:
-        Tuple of (body_fields, request_schema, graphql_body)
+        Tuple of (body_fields, request_schema, graphql_body, request_body_defaults)
         - body_fields: List of field names for standard JSON/form bodies
         - request_schema: Resolved request schema dict (for standard bodies)
         - graphql_body: GraphQL body configuration dict (for GraphQL bodies)
+        - request_body_defaults: Default values for request body fields
     """
     body_fields: list[str] = []
     request_schema: dict[str, Any] | None = None
     graphql_body: dict[str, Any] | None = None
+    request_body_defaults: dict[str, Any] = {}
 
     if not request_body:
-        return body_fields, request_schema, graphql_body
+        return body_fields, request_schema, graphql_body, request_body_defaults
 
     # Check for GraphQL extension and extract GraphQL body configuration
     if request_body.x_airbyte_body_type:
@@ -216,7 +218,7 @@ def _extract_request_body_config(
         if isinstance(body_type_config, GraphQLBodyConfig):
             # Convert Pydantic model to dict, excluding None values
             graphql_body = body_type_config.model_dump(exclude_none=True, by_alias=False)
-            return body_fields, request_schema, graphql_body
+            return body_fields, request_schema, graphql_body, request_body_defaults
 
     # Parse standard request body
     for content_type_key, media_type in request_body.content.items():
@@ -226,11 +228,15 @@ def _extract_request_body_config(
         # Resolve all $refs in the schema using jsonref
         request_schema = resolve_schema_refs(schema, spec_dict)
 
-        # Extract body field names from resolved schema
+        # Extract body field names and defaults from resolved schema
         if isinstance(request_schema, dict) and "properties" in request_schema:
             body_fields = list(request_schema["properties"].keys())
+            # Extract default values for each property
+            for field_name, field_schema in request_schema["properties"].items():
+                if isinstance(field_schema, dict) and "default" in field_schema:
+                    request_body_defaults[field_name] = field_schema["default"]
 
-    return body_fields, request_schema, graphql_body
+    return body_fields, request_schema, graphql_body, request_body_defaults
 
 
 def convert_openapi_to_connector_model(spec: OpenAPIConnector) -> ConnectorModel:
@@ -315,6 +321,8 @@ def convert_openapi_to_connector_model(spec: OpenAPIConnector) -> ConnectorModel
             query_params: list[str] = []
             query_params_schema: dict[str, dict[str, Any]] = {}
             deep_object_params: list[str] = []
+            header_params: list[str] = []
+            header_params_schema: dict[str, dict[str, Any]] = {}
 
             if operation.parameters:
                 for param in operation.parameters:
@@ -336,9 +344,12 @@ def convert_openapi_to_connector_model(spec: OpenAPIConnector) -> ConnectorModel
                         # Check if this is a deepObject style parameter
                         if hasattr(param, "style") and param.style == "deepObject":
                             deep_object_params.append(param.name)
+                    elif param.in_ == "header":
+                        header_params.append(param.name)
+                        header_params_schema[param.name] = schema_info
 
-            # Extract body fields from request schema
-            body_fields, request_schema, graphql_body = _extract_request_body_config(operation.request_body, spec_dict)
+            # Extract body fields and defaults from request schema
+            body_fields, request_schema, graphql_body, request_body_defaults = _extract_request_body_config(operation.request_body, spec_dict)
 
             # Extract response schema
             response_schema = None
@@ -372,6 +383,9 @@ def convert_openapi_to_connector_model(spec: OpenAPIConnector) -> ConnectorModel
                 deep_object_params=deep_object_params,
                 path_params=path_params,
                 path_params_schema=path_params_schema,
+                header_params=header_params,
+                header_params_schema=header_params_schema,
+                request_body_defaults=request_body_defaults,
                 content_type=content_type,
                 request_schema=request_schema,
                 response_schema=response_schema,
@@ -535,6 +549,13 @@ def _parse_oauth2_config(scheme: Any) -> dict[str, str]:
     if x_token_extract:
         config["token_extract"] = x_token_extract
 
+    # Extract additional_headers from x-airbyte-auth-config extension
+    x_auth_config = getattr(scheme, "x_airbyte_auth_config", None)
+    if x_auth_config:
+        additional_headers = getattr(x_auth_config, "additional_headers", None)
+        if additional_headers:
+            config["additional_headers"] = additional_headers
+
     return config
 
 

airbyte_agent_zendesk_support/_vendored/connector_sdk/executor/local_executor.py

@@ -64,6 +64,7 @@ class _OperationContext:
         self.build_path = executor._build_path
         self.extract_query_params = executor._extract_query_params
         self.extract_body = executor._extract_body
+        self.extract_header_params = executor._extract_header_params
         self.build_request_body = executor._build_request_body
         self.determine_request_format = executor._determine_request_format
         self.validate_required_body_fields = executor._validate_required_body_fields
@@ -693,6 +694,40 @@ class LocalExecutor:
         """
         return {key: value for key, value in params.items() if key in allowed_fields and value is not None}
 
+    def _extract_header_params(self, endpoint: EndpointDefinition, params: dict[str, Any], body: dict[str, Any] | None = None) -> dict[str, str]:
+        """Extract header parameters from params and schema defaults.
+
+        Also adds Content-Type header when there's a request body (unless already specified
+        as a header parameter in the OpenAPI spec).
+
+        Args:
+            endpoint: Endpoint definition with header_params and header_params_schema
+            params: All parameters
+            body: Request body (if any) - used to determine if Content-Type should be added
+
+        Returns:
+            Dictionary of header name -> value
+        """
+        headers: dict[str, str] = {}
+
+        for header_name in endpoint.header_params:
+            # Check if value is provided in params
+            if header_name in params and params[header_name] is not None:
+                headers[header_name] = str(params[header_name])
+            # Otherwise, use default from schema if available
+            elif header_name in endpoint.header_params_schema:
+                default_value = endpoint.header_params_schema[header_name].get("default")
+                if default_value is not None:
+                    headers[header_name] = str(default_value)
+
+        # Add Content-Type header when there's a request body, but only if not already
+        # specified as a header parameter (which allows custom content types like
+        # application/vnd.spCampaign.v3+json)
+        if body is not None and endpoint.content_type and "Content-Type" not in headers:
+            headers["Content-Type"] = endpoint.content_type.value
+
+        return headers
+
     def _serialize_deep_object_params(self, params: dict[str, Any], deep_object_param_names: list[str]) -> dict[str, Any]:
         """Serialize deepObject parameters to bracket notation format.
 
@@ -848,7 +883,15 @@ class LocalExecutor:
             param_defaults = {name: schema.get("default") for name, schema in endpoint.query_params_schema.items() if "default" in schema}
             return self._build_graphql_body(endpoint.graphql_body, params, param_defaults)
         elif endpoint.body_fields:
-            return self._extract_body(endpoint.body_fields, params)
+            # Start with defaults from request body schema
+            body = dict(endpoint.request_body_defaults)
+            # Override with user-provided params (filtering out None values)
+            user_body = self._extract_body(endpoint.body_fields, params)
+            body.update(user_body)
+            return body if body else None
+        elif endpoint.request_body_defaults:
+            # If no body_fields but we have defaults, return the defaults
+            return dict(endpoint.request_body_defaults)
         return None
 
     def _flatten_form_data(self, data: dict[str, Any], parent_key: str = "") -> dict[str, Any]:
@@ -987,7 +1030,9 @@ class LocalExecutor:
 
         # Substitute variables from params
         if "variables" in graphql_config and graphql_config["variables"]:
-            body["variables"] = self._interpolate_variables(graphql_config["variables"], params, param_defaults)
+            variables = self._interpolate_variables(graphql_config["variables"], params, param_defaults)
+            # Filter out None values (optional fields not provided) - matches REST _extract_body() behavior
+            body["variables"] = {k: v for k, v in variables.items() if v is not None}
 
         # Add operation name if specified
         if "operationName" in graphql_config:
@@ -1222,15 +1267,22 @@ class LocalExecutor:
     def _extract_metadata(
         self,
         response_data: dict[str, Any],
+        response_headers: dict[str, str],
         endpoint: EndpointDefinition,
     ) -> dict[str, Any] | None:
         """Extract metadata from response using meta extractor.
 
-        Each field in meta_extractor dict is independently extracted using JSONPath.
+        Each field in meta_extractor dict is independently extracted using JSONPath
+        for body extraction, or special prefixes for header extraction:
+        - @link.{rel}: Extract URL from RFC 5988 Link header by rel type
+        - @header.{name}: Extract raw header value by header name
+        - Otherwise: JSONPath expression for body extraction
+
         Missing or invalid paths result in None for that field (no crash).
 
         Args:
             response_data: Full API response (before record extraction)
+            response_headers: HTTP response headers
             endpoint: Endpoint with optional meta extractor configuration
 
         Returns:
@@ -1241,11 +1293,15 @@ class LocalExecutor:
         Example:
             meta_extractor = {
                 "pagination": "$.records",
-                "request_id": "$.requestId"
+                "request_id": "$.requestId",
+                "next_page_url": "@link.next",
+                "rate_limit": "@header.X-RateLimit-Remaining"
             }
             Returns: {
                 "pagination": {"cursor": "abc", "total": 100},
-                "request_id": "xyz123"
+                "request_id": "xyz123",
+                "next_page_url": "https://api.example.com/data?cursor=abc",
+                "rate_limit": "99"
             }
         """
         # Check if endpoint has meta extractor
@@ -1255,26 +1311,96 @@ class LocalExecutor:
         extracted_meta: dict[str, Any] = {}
 
         # Extract each field independently
-        for field_name, jsonpath_expr_str in endpoint.meta_extractor.items():
+        for field_name, extractor_expr in endpoint.meta_extractor.items():
             try:
-                # Parse and apply JSONPath expression
-                jsonpath_expr = parse_jsonpath(jsonpath_expr_str)
-                matches = [match.value for match in jsonpath_expr.find(response_data)]
-
-                if matches:
-                    # Return first match (most common case)
-                    extracted_meta[field_name] = matches[0]
+                if extractor_expr.startswith("@link."):
+                    # RFC 5988 Link header extraction
+                    rel = extractor_expr[6:]
+                    extracted_meta[field_name] = self._extract_link_url(response_headers, rel)
+                elif extractor_expr.startswith("@header."):
+                    # Raw header value extraction (case-insensitive lookup)
+                    header_name = extractor_expr[8:]
+                    extracted_meta[field_name] = self._get_header_value(response_headers, header_name)
                 else:
-                    # Path not found - set to None
-                    extracted_meta[field_name] = None
+                    # JSONPath body extraction
+                    jsonpath_expr = parse_jsonpath(extractor_expr)
+                    matches = [match.value for match in jsonpath_expr.find(response_data)]
+
+                    if matches:
+                        # Return first match (most common case)
+                        extracted_meta[field_name] = matches[0]
+                    else:
+                        # Path not found - set to None
+                        extracted_meta[field_name] = None
 
             except Exception as e:
                 # Log error but continue with other fields
-                logging.warning(f"Failed to apply meta extractor for field '{field_name}' with path '{jsonpath_expr_str}': {e}. Setting to None.")
+                logging.warning(f"Failed to apply meta extractor for field '{field_name}' with expression '{extractor_expr}': {e}. Setting to None.")
                 extracted_meta[field_name] = None
 
         return extracted_meta
 
+    @staticmethod
+    def _extract_link_url(headers: dict[str, str], rel: str) -> str | None:
+        """Extract URL from RFC 5988 Link header by rel type.
+
+        Parses Link header format: <url>; param1="value1"; rel="next"; param2="value2"
+
+        Supports:
+        - Multiple parameters per link in any order
+        - Both quoted and unquoted rel values
+        - Multiple links separated by commas
+
+        Args:
+            headers: Response headers dict
+            rel: The rel type to extract (e.g., "next", "prev", "first", "last")
+
+        Returns:
+            The URL for the specified rel type, or None if not found
+        """
+        link_header = headers.get("Link") or headers.get("link", "")
+        if not link_header:
+            return None
+
+        for link_segment in re.split(r",(?=\s*<)", link_header):
+            link_segment = link_segment.strip()
+
+            url_match = re.match(r"<([^>]+)>", link_segment)
+            if not url_match:
+                continue
+
+            url = url_match.group(1)
+            params_str = link_segment[url_match.end() :]
+
+            rel_match = re.search(r';\s*rel="?([^";,]+)"?', params_str, re.IGNORECASE)
+            if rel_match and rel_match.group(1).strip() == rel:
+                return url
+
+        return None
+
+    @staticmethod
+    def _get_header_value(headers: dict[str, str], header_name: str) -> str | None:
+        """Get header value with case-insensitive lookup.
+
+        Args:
+            headers: Response headers dict
+            header_name: Header name to look up
+
+        Returns:
+            Header value or None if not found
+        """
+        # Try exact match first
+        if header_name in headers:
+            return headers[header_name]
+
+        # Case-insensitive lookup
+        header_name_lower = header_name.lower()
+        for key, value in headers.items():
+            if key.lower() == header_name_lower:
+                return value
+
+        return None
+
     def _validate_required_body_fields(self, endpoint: Any, params: dict[str, Any], action: Action, entity: str) -> None:
         """Validate that required body fields are present for CREATE/UPDATE operations.
 
@@ -1401,20 +1527,24 @@ class _StandardOperationHandler:
                 # Determine request format (json/data parameters)
                 request_kwargs = self.ctx.determine_request_format(endpoint, body)
 
+                # Extract header parameters from OpenAPI operation (pass body to add Content-Type)
+                header_params = self.ctx.extract_header_params(endpoint, params, body)
+
                 # Execute async HTTP request
-                response = await self.ctx.http_client.request(
+                response_data, response_headers = await self.ctx.http_client.request(
                     method=endpoint.method,
                     path=path,
                     params=query_params if query_params else None,
                     json=request_kwargs.get("json"),
                     data=request_kwargs.get("data"),
+                    headers=header_params if header_params else None,
                 )
 
                 # Extract metadata from original response (before record extraction)
-                metadata = self.ctx.executor._extract_metadata(response, endpoint)
+                metadata = self.ctx.executor._extract_metadata(response_data, response_headers, endpoint)
 
                 # Extract records if extractor configured
-                response = self.ctx.extract_records(response, endpoint)
+                response = self.ctx.extract_records(response_data, endpoint)
 
                 # Assume success with 200 status code if no exception raised
                 status_code = 200
@@ -1540,7 +1670,7 @@ class _DownloadOperationHandler:
                     request_format = self.ctx.determine_request_format(operation, request_body)
                     self.ctx.validate_required_body_fields(operation, params, action, entity)
 
-                    metadata_response = await self.ctx.http_client.request(
+                    metadata_response, _ = await self.ctx.http_client.request(
                         method=operation.method,
                         path=path,
                         params=query_params,
@@ -1555,7 +1685,7 @@ class _DownloadOperationHandler:
                     )
 
                     # Step 3: Stream file from extracted URL
-                    file_response = await self.ctx.http_client.request(
+                    file_response, _ = await self.ctx.http_client.request(
                         method="GET",
                         path=file_url,
                         headers=headers,
@@ -1563,7 +1693,7 @@ class _DownloadOperationHandler:
                     )
                 else:
                     # One-step direct download: stream file directly from endpoint
-                    file_response = await self.ctx.http_client.request(
+                    file_response, _ = await self.ctx.http_client.request(
                         method=operation.method,
                         path=path,
                         params=query_params,