airbyte-agent-hubspot 0.15.25__py3-none-any.whl → 0.15.43__py3-none-any.whl

airbyte_agent_hubspot/_vendored/connector_sdk/executor/local_executor.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import inspect
 import logging
 import os
 import re
@@ -11,6 +12,7 @@ from collections.abc import AsyncIterator
 from typing import Any, Protocol
 from urllib.parse import quote
 
+from jinja2 import Environment, StrictUndefined
 from jsonpath_ng import parse as parse_jsonpath
 from opentelemetry import trace
 
@@ -506,8 +508,6 @@ class LocalExecutor:
             result = handler.execute_operation(config.entity, action, params)
 
             # Check if it's an async generator (download) or awaitable (standard)
-            import inspect
-
             if inspect.isasyncgen(result):
                 # Download operation: return generator directly
                 return ExecutionResult(
@@ -674,16 +674,16 @@ class LocalExecutor:
         return {key: value for key, value in params.items() if key in allowed_params}
 
     def _extract_body(self, allowed_fields: list[str], params: dict[str, Any]) -> dict[str, Any]:
-        """Extract body fields from params.
+        """Extract body fields from params, filtering out None values.
 
         Args:
             allowed_fields: List of allowed body field names
             params: All parameters
 
         Returns:
-            Dictionary of body fields
+            Dictionary of body fields with None values filtered out
         """
-        return {key: value for key, value in params.items() if key in allowed_fields}
+        return {key: value for key, value in params.items() if key in allowed_fields and value is not None}
 
     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.
@@ -814,7 +814,6 @@ class LocalExecutor:
             >>> _substitute_file_field_params("attachments[{attachment_index}].url", {"attachment_index": 0})
             "attachments[0].url"
         """
-        from jinja2 import Environment, StrictUndefined
 
         # Use custom delimiters to match OpenAPI path parameter syntax {var}
         # StrictUndefined raises clear error if a template variable is missing
@@ -837,15 +836,65 @@ class LocalExecutor:
             Request body dict or None if no body needed
         """
         if endpoint.graphql_body:
-            return self._build_graphql_body(endpoint.graphql_body, params)
+            # Extract defaults from query_params_schema for GraphQL variable interpolation
+            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)
         return None
 
+    def _flatten_form_data(self, data: dict[str, Any], parent_key: str = "") -> dict[str, Any]:
+        """Flatten nested dict/list structures into bracket notation for form encoding.
+
+        Stripe and similar APIs require nested arrays/objects to be encoded using bracket
+        notation when using application/x-www-form-urlencoded content type.
+
+        Args:
+            data: Nested dict with arrays/objects to flatten
+            parent_key: Parent key for nested structures (used in recursion)
+
+        Returns:
+            Flattened dict with bracket notation keys
+
+        Examples:
+            >>> _flatten_form_data({"items": [{"price": "p1", "qty": 1}]})
+            {"items[0][price]": "p1", "items[0][qty]": 1}
+
+            >>> _flatten_form_data({"customer": "cus_123", "metadata": {"key": "value"}})
+            {"customer": "cus_123", "metadata[key]": "value"}
+        """
+        flattened = {}
+
+        for key, value in data.items():
+            new_key = f"{parent_key}[{key}]" if parent_key else key
+
+            if isinstance(value, dict):
+                # Recursively flatten nested dicts
+                flattened.update(self._flatten_form_data(value, new_key))
+            elif isinstance(value, list):
+                # Flatten arrays with indexed bracket notation
+                for i, item in enumerate(value):
+                    indexed_key = f"{new_key}[{i}]"
+                    if isinstance(item, dict):
+                        # Nested dict in array - recurse
+                        flattened.update(self._flatten_form_data(item, indexed_key))
+                    elif isinstance(item, list):
+                        # Nested list in array - recurse
+                        flattened.update(self._flatten_form_data({str(i): item}, new_key))
+                    else:
+                        # Primitive value in array
+                        flattened[indexed_key] = item
+            else:
+                # Primitive value - add directly
+                flattened[new_key] = value
+
+        return flattened
+
     def _determine_request_format(self, endpoint: EndpointDefinition, body: dict[str, Any] | None) -> dict[str, Any]:
         """Determine json/data parameters for HTTP request.
 
         GraphQL always uses JSON, regardless of content_type setting.
+        For form-encoded requests, nested structures are flattened into bracket notation.
 
         Args:
             endpoint: Endpoint definition
@@ -862,7 +911,9 @@ class LocalExecutor:
         if is_graphql or endpoint.content_type.value == "application/json":
             return {"json": body}
         elif endpoint.content_type.value == "application/x-www-form-urlencoded":
-            return {"data": body}
+            # Flatten nested structures for form encoding
+            flattened_body = self._flatten_form_data(body)
+            return {"data": flattened_body}
 
         return {}
 
@@ -903,12 +954,18 @@ class LocalExecutor:
 
         return query
 
-    def _build_graphql_body(self, graphql_config: dict[str, Any], params: dict[str, Any]) -> dict[str, Any]:
+    def _build_graphql_body(
+        self,
+        graphql_config: dict[str, Any],
+        params: dict[str, Any],
+        param_defaults: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         """Build GraphQL request body with variable substitution and field selection.
 
         Args:
             graphql_config: GraphQL configuration from x-airbyte-body-type extension
             params: Parameters from execute() call
+            param_defaults: Default values for params from query_params_schema
 
         Returns:
             GraphQL request body: {"query": "...", "variables": {...}}
@@ -922,7 +979,7 @@ class LocalExecutor:
 
         # Substitute variables from params
         if "variables" in graphql_config and graphql_config["variables"]:
-            body["variables"] = self._interpolate_variables(graphql_config["variables"], params)
+            body["variables"] = self._interpolate_variables(graphql_config["variables"], params, param_defaults)
 
         # Add operation name if specified
         if "operationName" in graphql_config:
@@ -981,7 +1038,12 @@ class LocalExecutor:
         fields_str = " ".join(graphql_fields)
         return query.replace("{{ fields }}", fields_str)
 
-    def _interpolate_variables(self, variables: dict[str, Any], params: dict[str, Any]) -> dict[str, Any]:
+    def _interpolate_variables(
+        self,
+        variables: dict[str, Any],
+        params: dict[str, Any],
+        param_defaults: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         """Recursively interpolate variables using params.
 
         Preserves types (doesn't stringify everything).
@@ -990,15 +1052,18 @@ class LocalExecutor:
         - Direct replacement: "{{ owner }}" → params["owner"] (preserves type)
         - Nested objects: {"input": {"name": "{{ name }}"}}
         - Arrays: [{"id": "{{ id }}"}]
-        - Unsubstituted placeholders: "{{ states }}" → None (for optional params)
+        - Default values: "{{ per_page }}" → param_defaults["per_page"] if not in params
+        - Unsubstituted placeholders: "{{ states }}" → None (for optional params without defaults)
 
         Args:
             variables: Variables dict with template placeholders
             params: Parameters to substitute
+            param_defaults: Default values for params from query_params_schema
 
         Returns:
             Interpolated variables dict with types preserved
         """
+        defaults = param_defaults or {}
 
         def interpolate_value(value: Any) -> Any:
             if isinstance(value, str):
@@ -1012,8 +1077,15 @@ class LocalExecutor:
                         value = value.replace(placeholder, str(param_value))
 
                 # Check if any unsubstituted placeholders remain
-                # If so, return None (treats as "not provided" for optional params)
                 if re.search(r"\{\{\s*\w+\s*\}\}", value):
+                    # Extract placeholder name and check for default value
+                    match = re.search(r"\{\{\s*(\w+)\s*\}\}", value)
+                    if match:
+                        param_name = match.group(1)
+                        if param_name in defaults:
+                            # Use default value (preserves type)
+                            return defaults[param_name]
+                    # No default found - return None (for optional params)
                     return None
 
                 return value
@@ -1026,37 +1098,95 @@ class LocalExecutor:
 
         return interpolate_value(variables)
 
+    def _wrap_primitives(self, data: Any) -> dict[str, Any] | list[dict[str, Any]] | None:
+        """Wrap primitive values in dict format for consistent response structure.
+
+        Transforms primitive API responses into dict format so downstream code
+        can always expect dict-based data structures.
+
+        Args:
+            data: Response data (could be primitive, list, dict, or None)
+
+        Returns:
+            - If data is a primitive (str, int, float, bool): {"value": data}
+            - If data is a list: wraps all non-dict elements as {"value": item}
+            - If data is already a dict or list of dicts: unchanged
+            - If data is None: None
+
+        Examples:
+            >>> executor._wrap_primitives(42)
+            {"value": 42}
+            >>> executor._wrap_primitives([1, 2, 3])
+            [{"value": 1}, {"value": 2}, {"value": 3}]
+            >>> executor._wrap_primitives([1, {"id": 2}, 3])
+            [{"value": 1}, {"id": 2}, {"value": 3}]
+            >>> executor._wrap_primitives([[1, 2], 3])
+            [{"value": [1, 2]}, {"value": 3}]
+            >>> executor._wrap_primitives({"id": 1})
+            {"id": 1}  # unchanged
+        """
+        if data is None:
+            return None
+
+        # Handle primitive scalars
+        if isinstance(data, (bool, str, int, float)):
+            return {"value": data}
+
+        # Handle lists - wrap non-dict elements
+        if isinstance(data, list):
+            if not data:
+                return []  # Empty list unchanged
+
+            wrapped = []
+            for item in data:
+                if isinstance(item, dict):
+                    wrapped.append(item)
+                else:
+                    wrapped.append({"value": item})
+            return wrapped
+
+        # Dict - return unchanged
+        if isinstance(data, dict):
+            return data
+
+        # Unknown type - wrap for safety
+        return {"value": data}
+
     def _extract_records(
         self,
-        response_data: dict[str, Any],
+        response_data: Any,
         endpoint: EndpointDefinition,
-    ) -> dict[str, Any] | list[Any] | None:
+    ) -> dict[str, Any] | list[dict[str, Any]] | None:
         """Extract records from response using record extractor.
 
         Type inference based on action:
         - list, search: Returns array ([] if not found)
         - get, create, update, delete: Returns single record (None if not found)
 
+        Automatically wraps primitive values (int, str, float, bool) in {"value": primitive}
+        format to ensure consistent dict-based responses for downstream code.
+
         Args:
-            response_data: Full API response
+            response_data: Full API response (can be dict, list, primitive, or None)
             endpoint: Endpoint with optional record extractor and action
 
         Returns:
             - Extracted data if extractor configured and path found
             - [] or None if path not found (based on action)
             - Original response if no extractor configured or on error
+            - Primitives are wrapped as {"value": primitive}
         """
         # Check if endpoint has record extractor
         extractor = endpoint.record_extractor
         if not extractor:
-            return response_data
+            return self._wrap_primitives(response_data)
 
         # Determine if this action returns array or single record
         action = endpoint.action
         if not action:
-            return response_data
+            return self._wrap_primitives(response_data)
 
-        is_array_action = action in (Action.LIST, Action.SEARCH)
+        is_array_action = action in (Action.LIST, Action.API_SEARCH)
 
         try:
             # Parse and apply JSONPath expression
@@ -1067,17 +1197,19 @@ class LocalExecutor:
                 # Path not found - return empty based on action
                 return [] if is_array_action else None
 
-            # Return extracted data
+            # Return extracted data with primitive wrapping
             if is_array_action:
                 # For array actions, return the array (or list of matches)
-                return matches[0] if len(matches) == 1 else matches
+                result = matches[0] if len(matches) == 1 else matches
             else:
                 # For single record actions, return first match
-                return matches[0]
+                result = matches[0]
+
+            return self._wrap_primitives(result)
 
         except Exception as e:
             logging.warning(f"Failed to apply record extractor '{extractor}': {e}. Returning original response.")
-            return response_data
+            return self._wrap_primitives(response_data)
 
     def _extract_metadata(
         self,
@@ -1151,17 +1283,14 @@ class LocalExecutor:
         if action not in (Action.CREATE, Action.UPDATE):
             return
 
-        # Check if endpoint has body fields defined
-        if not endpoint.body_fields:
+        # Get the request schema to find truly required fields
+        request_schema = endpoint.request_schema
+        if not request_schema:
             return
 
-        # For now, we treat all body_fields as potentially required for CREATE/UPDATE
-        # In a more advanced implementation, we could parse the request schema
-        # to identify truly required fields
-        missing_fields = []
-        for field in endpoint.body_fields:
-            if field not in params:
-                missing_fields.append(field)
+        # Only validate fields explicitly marked as required in the schema
+        required_fields = request_schema.get("required", [])
+        missing_fields = [field for field in required_fields if field not in params]
 
         if missing_fields:
             raise MissingParameterError(
@@ -1189,7 +1318,7 @@ class LocalExecutor:
 
 
 class _StandardOperationHandler:
-    """Handler for standard REST operations (GET, LIST, CREATE, UPDATE, DELETE, SEARCH, AUTHORIZE)."""
+    """Handler for standard REST operations (GET, LIST, CREATE, UPDATE, DELETE, API_SEARCH, AUTHORIZE)."""
 
     def __init__(self, context: _OperationContext):
         self.ctx = context
@@ -1202,7 +1331,7 @@ class _StandardOperationHandler:
             Action.CREATE,
             Action.UPDATE,
             Action.DELETE,
-            Action.SEARCH,
+            Action.API_SEARCH,
             Action.AUTHORIZE,
         }
 

airbyte_agent_hubspot/_vendored/connector_sdk/extensions.py

@@ -159,6 +159,38 @@ Example:
     ```
 """
 
+AIRBYTE_STREAM_NAME = "x-airbyte-stream-name"
+"""
+Extension: x-airbyte-stream-name
+Location: Schema object (in components.schemas)
+Type: string
+Required: No
+
+Description:
+    Specifies the Airbyte stream name for cache lookup purposes. This maps the entity
+    to the corresponding Airbyte stream, enabling cache-based data retrieval. When
+    specified, the EntityDefinition.stream_name field will be populated with this value.
+
+    This extension is placed on Schema objects alongside x-airbyte-entity-name, following
+    the same pattern. The stream name is an entity-level property (not operation-level)
+    since an entity maps to exactly one Airbyte stream.
+
+Example:
+    ```yaml
+    components:
+      schemas:
+        Customer:
+          type: object
+          x-airbyte-entity-name: customers
+          x-airbyte-stream-name: customers
+          properties:
+            id:
+              type: string
+            name:
+              type: string
+    ```
+"""
+
 AIRBYTE_TOKEN_PATH = "x-airbyte-token-path"
 """
 Extension: x-airbyte-token-path
@@ -495,8 +527,8 @@ class ActionType(str, Enum):
     DELETE = "delete"
     """Delete a record"""
 
-    SEARCH = "search"
-    """Search for records matching specific query criteria"""
+    API_SEARCH = "api_search"
+    """Search for records matching specific query criteria via API"""
 
     DOWNLOAD = "download"
     """Download file content from a URL specified in the metadata response"""
@@ -514,7 +546,7 @@ class BodyType(str, Enum):
 
 
 # Type alias for use in Pydantic models
-ActionTypeLiteral = Literal["get", "list", "create", "update", "delete", "search", "download"]
+ActionTypeLiteral = Literal["get", "list", "create", "update", "delete", "api_search", "download"]
 
 
 # =============================================================================
@@ -548,6 +580,7 @@ def get_all_extension_names() -> list[str]:
         AIRBYTE_ENTITY,
         AIRBYTE_ACTION,
         AIRBYTE_ENTITY_NAME,
+        AIRBYTE_STREAM_NAME,
         AIRBYTE_TOKEN_PATH,
         AIRBYTE_BODY_TYPE,
         AIRBYTE_PATH_OVERRIDE,
@@ -594,6 +627,12 @@ EXTENSION_REGISTRY = {
         "required": False,
         "description": "Links schema to an entity/stream",
     },
+    AIRBYTE_STREAM_NAME: {
+        "location": "schema",
+        "type": "string",
+        "required": False,
+        "description": "Maps entity to Airbyte stream for cache lookup",
+    },
     AIRBYTE_TOKEN_PATH: {
         "location": "securityScheme",
         "type": "string",
@@ -627,8 +666,7 @@ EXTENSION_REGISTRY = {
         "type": "dict[str, str]",
         "required": False,
         "description": (
-            "Dictionary mapping field names to JSONPath expressions for extracting metadata "
-            "(pagination, request IDs, etc.) from response envelopes"
+            "Dictionary mapping field names to JSONPath expressions for extracting metadata (pagination, request IDs, etc.) from response envelopes"
         ),
     },
     AIRBYTE_FILE_URL: {

airbyte_agent_hubspot/_vendored/connector_sdk/http/response.py

@@ -80,6 +80,8 @@ class HTTPResponse:
             HTTPStatusError: For 4xx or 5xx status codes.
         """
         if 400 <= self._status_code < 600:
+            # NOTE: Import here intentionally to avoid circular import.
+            # exceptions.py imports HTTPResponse for type hints.
             from .exceptions import HTTPStatusError
 
             raise HTTPStatusError(