airbyte-cdk 6.44.0__py3-none-any.whl → 6.45.0__py3-none-any.whl

airbyte_cdk/sources/declarative/declarative_component_schema.yaml

@@ -341,7 +341,7 @@ definitions:
     properties:
       type:
         type: string
-        enum: [ DynamicStreamCheckConfig ]
+        enum: [DynamicStreamCheckConfig]
       dynamic_stream_name:
         title: Dynamic Stream Name
         description: The dynamic stream name.
@@ -1752,6 +1752,30 @@ definitions:
       $parameters:
         type: object
         additionalProperties: true
+  GroupByKeyMergeStrategy:
+    title: Group by Key
+    description: Record merge strategy that combines records according to fields on the record.
+    required:
+      - type
+      - key
+    properties:
+      type:
+        type: string
+        enum: [GroupByKeyMergeStrategy]
+      key:
+        title: Key
+        description: The name of the field on the record whose value will be used to group properties that were retrieved through multiple API requests.
+        anyOf:
+          - type: string
+          - type: array
+            items:
+              type: string
+        examples:
+          - "id"
+          - ["parent_id", "end_date"]
+      $parameters:
+        type: object
+        additionalProperties: true
   SessionTokenAuthenticator:
     type: object
     required:
@@ -1971,7 +1995,9 @@ definitions:
           - type: string
           - type: object
             additionalProperties:
-              type: string
+              anyOf:
+                - type: string
+                - $ref": "#/definitions/QueryProperties"
         interpolation_context:
           - next_page_token
           - stream_interval
@@ -2989,6 +3015,96 @@ definitions:
     examples:
       - id
       - ["code", "type"]
+  PropertiesFromEndpoint:
+    title: Properties from Endpoint
+    description: Defines the behavior for fetching the list of properties from an API that will be loaded into the requests to extract records.
+    type: object
+    required:
+      - type
+      - property_field_path
+      - retriever
+    properties:
+      type:
+        type: string
+        enum: [PropertiesFromEndpoint]
+      property_field_path:
+        description: Describes the path to the field that should be extracted
+        type: array
+        items:
+          type: string
+        examples:
+          - ["name"]
+        interpolation_context:
+          - config
+          - parameters
+      retriever:
+        description: Requester component that describes how to fetch the properties to query from a remote API endpoint.
+        anyOf:
+          - "$ref": "#/definitions/CustomRetriever"
+          - "$ref": "#/definitions/SimpleRetriever"
+      $parameters:
+        type: object
+        additionalProperties: true
+  PropertyChunking:
+    title: Property Chunking
+    description: For APIs with restrictions on the amount of properties that can be requester per request, property chunking can be applied to make multiple requests with a subset of the properties.
+    type: object
+    required:
+      - type
+      - property_limit_type
+    properties:
+      type:
+        type: string
+        enum: [PropertyChunking]
+      property_limit_type:
+        title: Property Limit Type
+        description: The type used to determine the maximum number of properties per chunk
+        enum:
+          - characters
+          - property_count
+      property_limit:
+        title: Property Limit
+        description: The maximum amount of properties that can be retrieved per request according to the limit type.
+        type: integer
+      record_merge_strategy:
+        title: Record Merge Strategy
+        description: Dictates how to records that require multiple requests to get all properties should be emitted to the destination
+        "$ref": "#/definitions/GroupByKeyMergeStrategy"
+      $parameters:
+        type: object
+        additionalProperties: true
+  QueryProperties:
+    title: Query Properties
+    description: For APIs that require explicit specification of the properties to query for, this component specifies which property fields and how they are supplied to outbound requests.
+    type: object
+    required:
+      - type
+      - property_list
+    properties:
+      type:
+        type: string
+        enum: [QueryProperties]
+      property_list:
+        title: Property List
+        description: The set of properties that will be queried for in the outbound request. This can either be statically defined or dynamic based on an API endpoint
+        anyOf:
+          - type: array
+            items:
+              type: string
+          - "$ref": "#/definitions/PropertiesFromEndpoint"
+      always_include_properties:
+        title: Always Include Properties
+        description: The list of properties that should be included in every set of properties when multiple chunks of properties are being requested.
+        type: array
+        items:
+          type: string
+      property_chunking:
+        title: Property Chunking
+        description: Defines how query properties will be grouped into smaller sets for APIs with limitations on the number of properties fetched per API request.
+        "$ref": "#/definitions/PropertyChunking"
+      $parameters:
+        type: object
+        additionalProperties: true
   RecordFilter:
     title: Record Filter
     description: Filter applied on a list of records.

airbyte_cdk/sources/declarative/models/declarative_component_schema.py

@@ -1,3 +1,5 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
 # generated by datamodel-codegen:
 #   filename:  declarative_component_schema.yaml
 
@@ -49,7 +51,7 @@ class DynamicStreamCheckConfig(BaseModel):
     )
     stream_count: Optional[int] = Field(
         0,
-        description="Numbers of the streams to try reading from when running a check operation.",
+        description="The number of streams to attempt reading from during a check operation. If `stream_count` exceeds the total number of available streams, the minimum of the two values will be used.",
         title="Stream Count",
     )
 
@@ -718,6 +720,17 @@ class ExponentialBackoffStrategy(BaseModel):
     parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
 
 
+class GroupByKeyMergeStrategy(BaseModel):
+    type: Literal["GroupByKeyMergeStrategy"]
+    key: Union[str, List[str]] = Field(
+        ...,
+        description="The name of the field on the record whose value will be used to group properties that were retrieved through multiple API requests.",
+        examples=["id", ["parent_id", "end_date"]],
+        title="Key",
+    )
+    parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
+
+
 class SessionTokenRequestBearerAuthenticator(BaseModel):
     type: Literal["Bearer"]
 
@@ -1189,6 +1202,31 @@ class PrimaryKey(BaseModel):
     )
 
 
+class PropertyLimitType(Enum):
+    characters = "characters"
+    property_count = "property_count"
+
+
+class PropertyChunking(BaseModel):
+    type: Literal["PropertyChunking"]
+    property_limit_type: PropertyLimitType = Field(
+        ...,
+        description="The type used to determine the maximum number of properties per chunk",
+        title="Property Limit Type",
+    )
+    property_limit: Optional[int] = Field(
+        None,
+        description="The maximum amount of properties that can be retrieved per request according to the limit type.",
+        title="Property Limit",
+    )
+    record_merge_strategy: Optional[GroupByKeyMergeStrategy] = Field(
+        None,
+        description="Dictates how to records that require multiple requests to get all properties should be emitted to the destination",
+        title="Record Merge Strategy",
+    )
+    parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
+
+
 class RecordFilter(BaseModel):
     type: Literal["RecordFilter"]
     condition: Optional[str] = Field(
@@ -2187,7 +2225,7 @@ class HttpRequester(BaseModel):
         examples=[{"Output-Format": "JSON"}, {"Version": "{{ config['version'] }}"}],
         title="Request Headers",
     )
-    request_parameters: Optional[Union[str, Dict[str, str]]] = Field(
+    request_parameters: Optional[Union[str, Dict[str, Union[str, Any]]]] = Field(
         None,
         description="Specifies the query parameters that should be set on an outgoing HTTP request given the inputs.",
         examples=[
@@ -2277,6 +2315,40 @@ class ParentStreamConfig(BaseModel):
     parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
 
 
+class PropertiesFromEndpoint(BaseModel):
+    type: Literal["PropertiesFromEndpoint"]
+    property_field_path: List[str] = Field(
+        ...,
+        description="Describes the path to the field that should be extracted",
+        examples=[["name"]],
+    )
+    retriever: Union[CustomRetriever, SimpleRetriever] = Field(
+        ...,
+        description="Requester component that describes how to fetch the properties to query from a remote API endpoint.",
+    )
+    parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
+
+
+class QueryProperties(BaseModel):
+    type: Literal["QueryProperties"]
+    property_list: Union[List[str], PropertiesFromEndpoint] = Field(
+        ...,
+        description="The set of properties that will be queried for in the outbound request. This can either be statically defined or dynamic based on an API endpoint",
+        title="Property List",
+    )
+    always_include_properties: Optional[List[str]] = Field(
+        None,
+        description="The list of properties that should be included in every set of properties when multiple chunks of properties are being requested.",
+        title="Always Include Properties",
+    )
+    property_chunking: Optional[PropertyChunking] = Field(
+        None,
+        description="Defines how query properties will be grouped into smaller sets for APIs with limitations on the number of properties fetched per API request.",
+        title="Property Chunking",
+    )
+    parameters: Optional[Dict[str, Any]] = Field(None, alias="$parameters")
+
+
 class StateDelegatingStream(BaseModel):
     type: Literal["StateDelegatingStream"]
     name: str = Field(..., description="The stream name.", example=["Users"], title="Name")
@@ -2525,5 +2597,6 @@ DeclarativeStream.update_forward_refs()
 SessionTokenAuthenticator.update_forward_refs()
 DynamicSchemaLoader.update_forward_refs()
 ParentStreamConfig.update_forward_refs()
+PropertiesFromEndpoint.update_forward_refs()
 SimpleRetriever.update_forward_refs()
 AsyncRetriever.update_forward_refs()

airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
 #
 
 from __future__ import annotations
@@ -234,6 +234,9 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     FlattenFields as FlattenFieldsModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    GroupByKeyMergeStrategy as GroupByKeyMergeStrategyModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     GroupingPartitionRouter as GroupingPartitionRouterModel,
 )
@@ -324,6 +327,18 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     ParentStreamConfig as ParentStreamConfigModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    PropertiesFromEndpoint as PropertiesFromEndpointModel,
+)
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    PropertyChunking as PropertyChunkingModel,
+)
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    PropertyLimitType as PropertyLimitTypeModel,
+)
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    QueryProperties as QueryPropertiesModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     Rate as RateModel,
 )
@@ -432,6 +447,17 @@ from airbyte_cdk.sources.declarative.requesters.paginators.strategies import (
     PageIncrement,
     StopConditionPaginationStrategyDecorator,
 )
+from airbyte_cdk.sources.declarative.requesters.query_properties import (
+    PropertiesFromEndpoint,
+    PropertyChunking,
+    QueryProperties,
+)
+from airbyte_cdk.sources.declarative.requesters.query_properties.property_chunking import (
+    PropertyLimitType,
+)
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies import (
+    GroupByKey,
+)
 from airbyte_cdk.sources.declarative.requesters.request_option import RequestOptionType
 from airbyte_cdk.sources.declarative.requesters.request_options import (
     DatetimeBasedRequestOptionsProvider,
@@ -596,6 +622,7 @@ class ModelToComponentFactory:
             ResponseToFileExtractorModel: self.create_response_to_file_extractor,
             ExponentialBackoffStrategyModel: self.create_exponential_backoff_strategy,
             SessionTokenAuthenticatorModel: self.create_session_token_authenticator,
+            GroupByKeyMergeStrategyModel: self.create_group_by_key,
             HttpRequesterModel: self.create_http_requester,
             HttpResponseFilterModel: self.create_http_response_filter,
             InlineSchemaLoaderModel: self.create_inline_schema_loader,
@@ -625,6 +652,9 @@ class ModelToComponentFactory:
             OffsetIncrementModel: self.create_offset_increment,
             PageIncrementModel: self.create_page_increment,
             ParentStreamConfigModel: self.create_parent_stream_config,
+            PropertiesFromEndpointModel: self.create_properties_from_endpoint,
+            PropertyChunkingModel: self.create_property_chunking,
+            QueryPropertiesModel: self.create_query_properties,
             RecordFilterModel: self.create_record_filter,
             RecordSelectorModel: self.create_record_selector,
             RemoveFieldsModel: self.create_remove_fields,
@@ -2083,8 +2113,8 @@ class ModelToComponentFactory:
             parameters=model.parameters or {},
         )
 
+    @staticmethod
     def create_response_to_file_extractor(
-        self,
         model: ResponseToFileExtractorModel,
         **kwargs: Any,
     ) -> ResponseToFileExtractor:
@@ -2098,11 +2128,17 @@ class ModelToComponentFactory:
             factor=model.factor or 5, parameters=model.parameters or {}, config=config
         )
 
+    @staticmethod
+    def create_group_by_key(model: GroupByKeyMergeStrategyModel, config: Config) -> GroupByKey:
+        return GroupByKey(model.key, config=config, parameters=model.parameters or {})
+
     def create_http_requester(
         self,
         model: HttpRequesterModel,
         config: Config,
         decoder: Decoder = JsonDecoder(parameters={}),
+        query_properties_key: Optional[str] = None,
+        use_cache: Optional[bool] = None,
         *,
         name: str,
     ) -> HttpRequester:
@@ -2135,6 +2171,7 @@ class ModelToComponentFactory:
             request_body_json=model.request_body_json,
             request_headers=model.request_headers,
             request_parameters=model.request_parameters,
+            query_properties_key=query_properties_key,
             config=config,
             parameters=model.parameters or {},
         )
@@ -2142,7 +2179,7 @@ class ModelToComponentFactory:
         assert model.use_cache is not None  # for mypy
         assert model.http_method is not None  # for mypy
 
-        use_cache = model.use_cache and not self._disable_cache
+        should_use_cache = (model.use_cache or bool(use_cache)) and not self._disable_cache
 
         return HttpRequester(
             name=name,
@@ -2157,7 +2194,7 @@ class ModelToComponentFactory:
             disable_retries=self._disable_retries,
             parameters=model.parameters or {},
             message_repository=self._message_repository,
-            use_cache=use_cache,
+            use_cache=should_use_cache,
             decoder=decoder,
             stream_response=decoder.is_stream_response() if decoder else False,
         )
@@ -2261,10 +2298,11 @@ class ModelToComponentFactory:
         retriever = self._create_component_from_model(
             model=model.retriever,
             config=config,
-            name="",
+            name="dynamic_properties",
             primary_key=None,
             stream_slicer=combined_slicers,
             transformations=[],
+            use_cache=True,
         )
         schema_type_identifier = self._create_component_from_model(
             model.schema_type_identifier, config=config, parameters=model.parameters or {}
@@ -2602,6 +2640,79 @@ class ModelToComponentFactory:
             lazy_read_pointer=model_lazy_read_pointer,
         )
 
+    def create_properties_from_endpoint(
+        self, model: PropertiesFromEndpointModel, config: Config, **kwargs: Any
+    ) -> PropertiesFromEndpoint:
+        retriever = self._create_component_from_model(
+            model=model.retriever,
+            config=config,
+            name="dynamic_properties",
+            primary_key=None,
+            stream_slicer=None,
+            transformations=[],
+            use_cache=True,  # Enable caching on the HttpRequester/HttpClient because the properties endpoint will be called for every slice being processed, and it is highly unlikely for the response to different
+        )
+        return PropertiesFromEndpoint(
+            property_field_path=model.property_field_path,
+            retriever=retriever,
+            config=config,
+            parameters=model.parameters or {},
+        )
+
+    def create_property_chunking(
+        self, model: PropertyChunkingModel, config: Config, **kwargs: Any
+    ) -> PropertyChunking:
+        record_merge_strategy = (
+            self._create_component_from_model(
+                model=model.record_merge_strategy, config=config, **kwargs
+            )
+            if model.record_merge_strategy
+            else None
+        )
+
+        property_limit_type: PropertyLimitType
+        match model.property_limit_type:
+            case PropertyLimitTypeModel.property_count:
+                property_limit_type = PropertyLimitType.property_count
+            case PropertyLimitTypeModel.characters:
+                property_limit_type = PropertyLimitType.characters
+            case _:
+                raise ValueError(f"Invalid PropertyLimitType {property_limit_type}")
+
+        return PropertyChunking(
+            property_limit_type=property_limit_type,
+            property_limit=model.property_limit,
+            record_merge_strategy=record_merge_strategy,
+            config=config,
+            parameters=model.parameters or {},
+        )
+
+    def create_query_properties(
+        self, model: QueryPropertiesModel, config: Config, **kwargs: Any
+    ) -> QueryProperties:
+        if isinstance(model.property_list, list):
+            property_list = model.property_list
+        else:
+            property_list = self._create_component_from_model(
+                model=model.property_list, config=config, **kwargs
+            )
+
+        property_chunking = (
+            self._create_component_from_model(
+                model=model.property_chunking, config=config, **kwargs
+            )
+            if model.property_chunking
+            else None
+        )
+
+        return QueryProperties(
+            property_list=property_list,
+            always_include_properties=model.always_include_properties,
+            property_chunking=property_chunking,
+            config=config,
+            parameters=model.parameters or {},
+        )
+
     @staticmethod
     def create_record_filter(
         model: RecordFilterModel, config: Config, **kwargs: Any
@@ -2747,6 +2858,7 @@ class ModelToComponentFactory:
                 IncrementingCountCursorModel, DatetimeBasedCursorModel, CustomIncrementalSyncModel
             ]
         ] = None,
+        use_cache: Optional[bool] = None,
         **kwargs: Any,
     ) -> SimpleRetriever:
         decoder = (
@@ -2754,9 +2866,6 @@ class ModelToComponentFactory:
             if model.decoder
             else JsonDecoder(parameters={})
         )
-        requester = self._create_component_from_model(
-            model=model.requester, decoder=decoder, config=config, name=name
-        )
         record_selector = self._create_component_from_model(
             model=model.record_selector,
             name=name,
@@ -2765,6 +2874,57 @@ class ModelToComponentFactory:
             transformations=transformations,
             client_side_incremental_sync=client_side_incremental_sync,
         )
+
+        query_properties: Optional[QueryProperties] = None
+        query_properties_key: Optional[str] = None
+        if (
+            hasattr(model.requester, "request_parameters")
+            and model.requester.request_parameters
+            and isinstance(model.requester.request_parameters, Mapping)
+        ):
+            query_properties_definitions = []
+            for key, request_parameter in model.requester.request_parameters.items():
+                # When translating JSON schema into Pydantic models, enforcing types for arrays containing both
+                # concrete string complex object definitions like QueryProperties would get resolved to Union[str, Any].
+                # This adds the extra validation that we couldn't get for free in Pydantic model generation
+                if (
+                    isinstance(request_parameter, Mapping)
+                    and request_parameter.get("type") == "QueryProperties"
+                ):
+                    query_properties_key = key
+                    query_properties_definitions.append(request_parameter)
+                elif not isinstance(request_parameter, str):
+                    raise ValueError(
+                        f"Each element of request_parameters should be of type str or QueryProperties, but received {request_parameter.get('type')}"
+                    )
+
+            if len(query_properties_definitions) > 1:
+                raise ValueError(
+                    f"request_parameters only supports defining one QueryProperties field, but found {len(query_properties_definitions)} usages"
+                )
+
+            if len(query_properties_definitions) == 1:
+                query_properties = self.create_component(
+                    model_type=QueryPropertiesModel,
+                    component_definition=query_properties_definitions[0],
+                    config=config,
+                )
+
+            # Removes QueryProperties components from the interpolated mappings because it will be resolved in
+            # the provider from the slice directly instead of through jinja interpolation
+            if isinstance(model.requester.request_parameters, Mapping):
+                model.requester.request_parameters = self._remove_query_properties(
+                    model.requester.request_parameters
+                )
+
+        requester = self._create_component_from_model(
+            model=model.requester,
+            decoder=decoder,
+            name=name,
+            query_properties_key=query_properties_key,
+            use_cache=use_cache,
+            config=config,
+        )
         url_base = (
             model.requester.url_base
             if hasattr(model.requester, "url_base")
@@ -2870,9 +3030,21 @@ class ModelToComponentFactory:
             cursor=cursor,
             config=config,
             ignore_stream_slicer_parameters_on_paginated_requests=ignore_stream_slicer_parameters_on_paginated_requests,
+            additional_query_properties=query_properties,
             parameters=model.parameters or {},
         )
 
+    @staticmethod
+    def _remove_query_properties(
+        request_parameters: Mapping[str, Union[Any, str]],
+    ) -> Mapping[str, Union[Any, str]]:
+        return {
+            parameter_field: request_parameter
+            for parameter_field, request_parameter in request_parameters.items()
+            if not isinstance(request_parameter, Mapping)
+            or not request_parameter.get("type") == "QueryProperties"
+        }
+
     def create_state_delegating_stream(
         self,
         model: StateDelegatingStreamModel,

airbyte_cdk/sources/declarative/requesters/query_properties/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from airbyte_cdk.sources.declarative.requesters.query_properties.properties_from_endpoint import (
+    PropertiesFromEndpoint,
+)
+from airbyte_cdk.sources.declarative.requesters.query_properties.property_chunking import (
+    PropertyChunking,
+)
+from airbyte_cdk.sources.declarative.requesters.query_properties.query_properties import (
+    QueryProperties,
+)
+
+__all__ = ["PropertiesFromEndpoint", "PropertyChunking", "QueryProperties"]

airbyte_cdk/sources/declarative/requesters/query_properties/properties_from_endpoint.py

@@ -0,0 +1,40 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from dataclasses import InitVar, dataclass
+from typing import Any, Iterable, List, Mapping, Optional
+
+import dpath
+
+from airbyte_cdk.sources.declarative.interpolation import InterpolatedString
+from airbyte_cdk.sources.declarative.retrievers import Retriever
+from airbyte_cdk.sources.types import Config, StreamSlice
+
+
+@dataclass
+class PropertiesFromEndpoint:
+    """
+    Component that defines the behavior around how to dynamically retrieve a set of request properties from an
+    API endpoint. The set retrieved can then be injected into the requests to extract records from an API source.
+    """
+
+    property_field_path: List[str]
+    retriever: Retriever
+    config: Config
+    parameters: InitVar[Mapping[str, Any]]
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        self._property_field_path = [
+            InterpolatedString(string=property_field, parameters=parameters)
+            for property_field in self.property_field_path
+        ]
+
+    def get_properties_from_endpoint(self, stream_slice: Optional[StreamSlice]) -> Iterable[str]:
+        response_properties = self.retriever.read_records(
+            records_schema={}, stream_slice=stream_slice
+        )
+        for property_obj in response_properties:
+            path = [
+                node.eval(self.config) if not isinstance(node, str) else node
+                for node in self._property_field_path
+            ]
+            yield dpath.get(property_obj, path, default=[])  # type: ignore # extracted will be a MutableMapping, given input data structure

airbyte_cdk/sources/declarative/requesters/query_properties/property_chunking.py

@@ -0,0 +1,69 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from dataclasses import InitVar, dataclass
+from enum import Enum
+from typing import Any, Iterable, List, Mapping, Optional
+
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies import GroupByKey
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies.merge_strategy import (
+    RecordMergeStrategy,
+)
+from airbyte_cdk.sources.types import Config, Record
+
+
+class PropertyLimitType(Enum):
+    """
+    The heuristic that determines when the maximum size of the current chunk of properties and when a new
+    one should be started.
+    """
+
+    characters = "characters"
+    property_count = "property_count"
+
+
+@dataclass
+class PropertyChunking:
+    """
+    Defines the behavior for how the complete list of properties to query for are broken down into smaller groups
+    that will be used for multiple requests to the target API.
+    """
+
+    property_limit_type: PropertyLimitType
+    property_limit: Optional[int]
+    record_merge_strategy: Optional[RecordMergeStrategy]
+    parameters: InitVar[Mapping[str, Any]]
+    config: Config
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        self._record_merge_strategy = self.record_merge_strategy or GroupByKey(
+            key="id", config=self.config, parameters=parameters
+        )
+
+    def get_request_property_chunks(
+        self, property_fields: Iterable[str], always_include_properties: Optional[List[str]]
+    ) -> Iterable[List[str]]:
+        if not self.property_limit:
+            single_property_chunk = list(property_fields)
+            if always_include_properties:
+                single_property_chunk.extend(always_include_properties)
+            yield single_property_chunk
+            return
+        current_chunk = list(always_include_properties) if always_include_properties else []
+        chunk_size = 0
+        for property_field in property_fields:
+            # If property_limit_type is not defined, we default to property_count which is just an incrementing count
+            property_field_size = (
+                len(property_field)
+                if self.property_limit_type == PropertyLimitType.characters
+                else 1
+            )
+            if chunk_size + property_field_size > self.property_limit:
+                yield current_chunk
+                current_chunk = list(always_include_properties) if always_include_properties else []
+                chunk_size = 0
+            current_chunk.append(property_field)
+            chunk_size += property_field_size
+        yield current_chunk
+
+    def get_merge_key(self, record: Record) -> Optional[str]:
+        return self._record_merge_strategy.get_group_key(record=record)

airbyte_cdk/sources/declarative/requesters/query_properties/query_properties.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from dataclasses import InitVar, dataclass
+from typing import Any, Iterable, List, Mapping, Optional, Union
+
+from airbyte_cdk.sources.declarative.requesters.query_properties import (
+    PropertiesFromEndpoint,
+    PropertyChunking,
+)
+from airbyte_cdk.sources.types import Config, StreamSlice
+
+
+@dataclass
+class QueryProperties:
+    """
+    Low-code component that encompasses the behavior to inject additional property values into the outbound API
+    requests. Property values can be defined statically within the manifest or dynamically by making requests
+    to a partner API to retrieve the properties. Query properties also allow for splitting of the total set of
+    properties into smaller chunks to satisfy API restrictions around the total amount of data retrieved
+    """
+
+    property_list: Optional[Union[List[str], PropertiesFromEndpoint]]
+    always_include_properties: Optional[List[str]]
+    property_chunking: Optional[PropertyChunking]
+    config: Config
+    parameters: InitVar[Mapping[str, Any]]
+
+    def get_request_property_chunks(
+        self, stream_slice: Optional[StreamSlice] = None
+    ) -> Iterable[List[str]]:
+        """
+        Uses the defined property_list to fetch the total set of properties dynamically or from a static list
+        and based on the resulting properties, performs property chunking if applicable.
+        :param stream_slice: The StreamSlice of the current partition being processed during the sync. This is included
+        because subcomponents of QueryProperties can make use of interpolation of the top-level StreamSlice object
+        """
+        fields: Union[Iterable[str], List[str]]
+        if isinstance(self.property_list, PropertiesFromEndpoint):
+            fields = self.property_list.get_properties_from_endpoint(stream_slice=stream_slice)
+        else:
+            fields = self.property_list if self.property_list else []
+
+        if self.property_chunking:
+            yield from self.property_chunking.get_request_property_chunks(
+                property_fields=fields, always_include_properties=self.always_include_properties
+            )
+        else:
+            yield list(fields)
+
+    # delete later, but leaving this to keep the discussion thread on the PR from getting hidden
+    def has_multiple_chunks(self, stream_slice: Optional[StreamSlice]) -> bool:
+        property_chunks = iter(self.get_request_property_chunks(stream_slice=stream_slice))
+        try:
+            next(property_chunks)
+            next(property_chunks)
+            return True
+        except StopIteration:
+            return False

airbyte_cdk/sources/declarative/requesters/query_properties/strategies/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies.group_by_key import (
+    GroupByKey,
+)
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies.merge_strategy import (
+    RecordMergeStrategy,
+)
+
+__all__ = ["GroupByKey", "RecordMergeStrategy"]

airbyte_cdk/sources/declarative/requesters/query_properties/strategies/group_by_key.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from dataclasses import InitVar, dataclass
+from typing import Any, List, Mapping, Optional, Union
+
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies.merge_strategy import (
+    RecordMergeStrategy,
+)
+from airbyte_cdk.sources.types import Config, Record
+
+
+@dataclass
+class GroupByKey(RecordMergeStrategy):
+    """
+    Record merge strategy that combines records together according to values on the record for one or many keys.
+    """
+
+    key: Union[str, List[str]]
+    parameters: InitVar[Mapping[str, Any]]
+    config: Config
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        self._keys = [self.key] if isinstance(self.key, str) else self.key
+
+    def get_group_key(self, record: Record) -> Optional[str]:
+        resolved_keys = []
+        for key in self._keys:
+            key_value = record.data.get(key)
+            if key_value:
+                resolved_keys.append(key_value)
+            else:
+                return None
+        return ",".join(resolved_keys)

airbyte_cdk/sources/declarative/requesters/query_properties/strategies/merge_strategy.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional
+
+from airbyte_cdk.sources.types import Record
+
+
+@dataclass
+class RecordMergeStrategy(ABC):
+    """
+    Describe the interface for how records that required multiple requests to get the complete set of fields
+    should be merged back into a single record.
+    """
+
+    @abstractmethod
+    def get_group_key(self, record: Record) -> Optional[str]:
+        pass

airbyte_cdk/sources/declarative/requesters/request_options/interpolated_request_options_provider.py

@@ -1,9 +1,9 @@
 #
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
 #
 
 from dataclasses import InitVar, dataclass, field
-from typing import Any, Mapping, MutableMapping, Optional, Union
+from typing import Any, List, Mapping, MutableMapping, Optional, Union
 
 from airbyte_cdk.sources.declarative.interpolation.interpolated_nested_mapping import NestedMapping
 from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_nested_request_input_provider import (
@@ -40,6 +40,7 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
     request_headers: Optional[RequestInput] = None
     request_body_data: Optional[RequestInput] = None
     request_body_json: Optional[NestedMapping] = None
+    query_properties_key: Optional[str] = None
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         if self.request_parameters is None:
@@ -83,6 +84,28 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
             valid_value_types=ValidRequestTypes,
         )
         if isinstance(interpolated_value, dict):
+            if self.query_properties_key:
+                if not stream_slice:
+                    raise ValueError(
+                        "stream_slice should not be None if query properties in requests is enabled. Please contact Airbyte Support"
+                    )
+                elif (
+                    "query_properties" not in stream_slice.extra_fields
+                    or stream_slice.extra_fields.get("query_properties") is None
+                ):
+                    raise ValueError(
+                        "QueryProperties component is defined but stream_partition does not contain query_properties. Please contact Airbyte Support"
+                    )
+                elif not isinstance(stream_slice.extra_fields.get("query_properties"), List):
+                    raise ValueError(
+                        "QueryProperties component is defined but stream_slice.extra_fields.query_properties is not a List. Please contact Airbyte Support"
+                    )
+                interpolated_value = {
+                    **interpolated_value,
+                    self.query_properties_key: ",".join(
+                        stream_slice.extra_fields.get("query_properties")  # type: ignore  # Earlier type checks validate query_properties type
+                    ),
+                }
             return interpolated_value
         return {}
 

airbyte_cdk/sources/declarative/retrievers/simple_retriever.py

@@ -1,8 +1,9 @@
 #
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
 #
 
 import json
+from collections import defaultdict
 from dataclasses import InitVar, dataclass, field
 from functools import partial
 from itertools import islice
@@ -12,6 +13,7 @@ from typing import (
     Iterable,
     List,
     Mapping,
+    MutableMapping,
     Optional,
     Set,
     Tuple,
@@ -31,6 +33,7 @@ from airbyte_cdk.sources.declarative.partition_routers.single_partition_router i
 )
 from airbyte_cdk.sources.declarative.requesters.paginators.no_pagination import NoPagination
 from airbyte_cdk.sources.declarative.requesters.paginators.paginator import Paginator
+from airbyte_cdk.sources.declarative.requesters.query_properties import QueryProperties
 from airbyte_cdk.sources.declarative.requesters.request_options import (
     DefaultRequestOptionsProvider,
     RequestOptionsProvider,
@@ -88,6 +91,7 @@ class SimpleRetriever(Retriever):
     )
     cursor: Optional[DeclarativeCursor] = None
     ignore_stream_slicer_parameters_on_paginated_requests: bool = False
+    additional_query_properties: Optional[QueryProperties] = None
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self._paginator = self.paginator or NoPagination(parameters=parameters)
@@ -445,43 +449,110 @@ class SimpleRetriever(Retriever):
         :param stream_slice: The stream slice to read data for
         :return: The records read from the API source
         """
-        _slice = stream_slice or StreamSlice(partition={}, cursor_slice={})  # None-check
 
-        most_recent_record_from_slice = None
-        record_generator = partial(
-            self._parse_records,
-            stream_slice=stream_slice,
-            stream_state=self.state or {},
-            records_schema=records_schema,
+        property_chunks = (
+            list(
+                self.additional_query_properties.get_request_property_chunks(
+                    stream_slice=stream_slice
+                )
+            )
+            if self.additional_query_properties
+            else []
         )
+        records_without_merge_key = []
+        merged_records: MutableMapping[str, Any] = defaultdict(dict)
 
-        if self.cursor and isinstance(self.cursor, ResumableFullRefreshCursor):
-            stream_state = self.state
-
-            # Before syncing the RFR stream, we check if the job's prior attempt was successful and don't need to
-            # fetch more records. The platform deletes stream state for full refresh streams before starting a
-            # new job, so we don't need to worry about this value existing for the initial attempt
-            if stream_state.get(FULL_REFRESH_SYNC_COMPLETE_KEY):
-                return
+        _slice = stream_slice or StreamSlice(partition={}, cursor_slice={})  # None-check
+        most_recent_record_from_slice = None
 
-            yield from self._read_single_page(record_generator, stream_state, _slice)
-        else:
-            for stream_data in self._read_pages(record_generator, self.state, _slice):
-                current_record = self._extract_record(stream_data, _slice)
-                if self.cursor and current_record:
-                    self.cursor.observe(_slice, current_record)
-
-                # Latest record read, not necessarily within slice boundaries.
-                # TODO Remove once all custom components implement `observe` method.
-                # https://github.com/airbytehq/airbyte-internal-issues/issues/6955
-                most_recent_record_from_slice = self._get_most_recent_record(
-                    most_recent_record_from_slice, current_record, _slice
+        if self.additional_query_properties:
+            for properties in property_chunks:
+                _slice = StreamSlice(
+                    partition=_slice.partition or {},
+                    cursor_slice=_slice.cursor_slice or {},
+                    extra_fields={"query_properties": properties},
+                )  # None-check
+
+                record_generator = partial(
+                    self._parse_records,
+                    stream_slice=_slice,
+                    stream_state=self.state or {},
+                    records_schema=records_schema,
                 )
-                yield stream_data
 
+                for stream_data in self._read_pages(record_generator, self.state, _slice):
+                    current_record = self._extract_record(stream_data, _slice)
+                    if self.cursor and current_record:
+                        self.cursor.observe(_slice, current_record)
+
+                    # Latest record read, not necessarily within slice boundaries.
+                    # TODO Remove once all custom components implement `observe` method.
+                    # https://github.com/airbytehq/airbyte-internal-issues/issues/6955
+                    most_recent_record_from_slice = self._get_most_recent_record(
+                        most_recent_record_from_slice, current_record, _slice
+                    )
+
+                    if current_record and self.additional_query_properties.property_chunking:
+                        merge_key = (
+                            self.additional_query_properties.property_chunking.get_merge_key(
+                                current_record
+                            )
+                        )
+                        if merge_key:
+                            merged_records[merge_key].update(current_record)
+                        else:
+                            # We should still emit records even if the record did not have a merge key
+                            records_without_merge_key.append(current_record)
+                    else:
+                        yield stream_data
             if self.cursor:
                 self.cursor.close_slice(_slice, most_recent_record_from_slice)
-        return
+
+            if len(merged_records) > 0:
+                yield from [
+                    Record(data=merged_record, stream_name=self.name, associated_slice=stream_slice)
+                    for merged_record in merged_records.values()
+                ]
+            if len(records_without_merge_key) > 0:
+                yield from records_without_merge_key
+        else:
+            _slice = stream_slice or StreamSlice(partition={}, cursor_slice={})  # None-check
+
+            most_recent_record_from_slice = None
+            record_generator = partial(
+                self._parse_records,
+                stream_slice=stream_slice,
+                stream_state=self.state or {},
+                records_schema=records_schema,
+            )
+
+            if self.cursor and isinstance(self.cursor, ResumableFullRefreshCursor):
+                stream_state = self.state
+
+                # Before syncing the RFR stream, we check if the job's prior attempt was successful and don't need to
+                # fetch more records. The platform deletes stream state for full refresh streams before starting a
+                # new job, so we don't need to worry about this value existing for the initial attempt
+                if stream_state.get(FULL_REFRESH_SYNC_COMPLETE_KEY):
+                    return
+
+                yield from self._read_single_page(record_generator, stream_state, _slice)
+            else:
+                for stream_data in self._read_pages(record_generator, self.state, _slice):
+                    current_record = self._extract_record(stream_data, _slice)
+                    if self.cursor and current_record:
+                        self.cursor.observe(_slice, current_record)
+
+                    # Latest record read, not necessarily within slice boundaries.
+                    # TODO Remove once all custom components implement `observe` method.
+                    # https://github.com/airbytehq/airbyte-internal-issues/issues/6955
+                    most_recent_record_from_slice = self._get_most_recent_record(
+                        most_recent_record_from_slice, current_record, _slice
+                    )
+                    yield stream_data
+
+                if self.cursor:
+                    self.cursor.close_slice(_slice, most_recent_record_from_slice)
+            return
 
     def _get_most_recent_record(
         self,

{airbyte_cdk-6.44.0.dist-info → airbyte_cdk-6.45.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: airbyte-cdk
-Version: 6.44.0
+Version: 6.45.0
 Summary: A framework for writing Airbyte Connectors.
 Home-page: https://airbyte.com
 License: MIT

{airbyte_cdk-6.44.0.dist-info → airbyte_cdk-6.45.0.dist-info}/RECORD

@@ -71,7 +71,7 @@ airbyte_cdk/sources/declarative/concurrent_declarative_source.py,sha256=uhy0dRkA
 airbyte_cdk/sources/declarative/datetime/__init__.py,sha256=4Hw-PX1-VgESLF16cDdvuYCzGJtHntThLF4qIiULWeo,61
 airbyte_cdk/sources/declarative/datetime/datetime_parser.py,sha256=_zGNGq31RNy_0QBLt_EcTvgPyhj7urPdx6oA3M5-r3o,3150
 airbyte_cdk/sources/declarative/datetime/min_max_datetime.py,sha256=0BHBtDNQZfvwM45-tY5pNlTcKAFSGGNxemoi0Jic-0E,5785
-airbyte_cdk/sources/declarative/declarative_component_schema.yaml,sha256=pMzxm5YCtLM30wPIniTQk39oFRzvzsq7R_Mj2KEmaSg,153851
+airbyte_cdk/sources/declarative/declarative_component_schema.yaml,sha256=pGFwleIC0sXFY-a6QphWyjY9QjUfHasgChPAMZFWjU8,158152
 airbyte_cdk/sources/declarative/declarative_source.py,sha256=nF7wBqFd3AQmEKAm4CnIo29CJoQL562cJGSCeL8U8bA,1531
 airbyte_cdk/sources/declarative/declarative_stream.py,sha256=dCRlddBUSaJmBNBz1pSO1r2rTw8AP5d2_vlmIeGs2gg,10767
 airbyte_cdk/sources/declarative/decoders/__init__.py,sha256=JHb_0d3SE6kNY10mxA5YBEKPeSbsWYjByq1gUQxepoE,953
@@ -114,13 +114,13 @@ airbyte_cdk/sources/declarative/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW
 airbyte_cdk/sources/declarative/migrations/legacy_to_per_partition_state_migration.py,sha256=iemy3fKLczcU0-Aor7tx5jcT6DRedKMqyK7kCOp01hg,3924
 airbyte_cdk/sources/declarative/migrations/state_migration.py,sha256=KWPjealMLKSMtajXgkdGgKg7EmTLR-CqqD7UIh0-eDU,794
 airbyte_cdk/sources/declarative/models/__init__.py,sha256=nUFxNCiKeYRVXuZEKA7GD-lTHxsiKcQ8FitZjKhPIvE,100
-airbyte_cdk/sources/declarative/models/declarative_component_schema.py,sha256=7lR9dulMMnCJps7hpbuN4Moh9FFG8sGaEIcsK4zi_7s,108868
+airbyte_cdk/sources/declarative/models/declarative_component_schema.py,sha256=EfhCFVz_UHl7_cbRlf5hvFO1J5osxAZjISeqgbXE2t8,112007
 airbyte_cdk/sources/declarative/parsers/__init__.py,sha256=ZnqYNxHsKCgO38IwB34RQyRMXTs4GTvlRi3ImKnIioo,61
 airbyte_cdk/sources/declarative/parsers/custom_code_compiler.py,sha256=nlVvHC511NUyDEEIRBkoeDTAvLqKNp-hRy8D19z8tdk,5941
 airbyte_cdk/sources/declarative/parsers/custom_exceptions.py,sha256=Rir9_z3Kcd5Es0-LChrzk-0qubAsiK_RSEnLmK2OXm8,553
 airbyte_cdk/sources/declarative/parsers/manifest_component_transformer.py,sha256=4C15MKV-zOrMVQAm4FyohDsrJUBCSpMv5tZw0SK3aeI,9685
 airbyte_cdk/sources/declarative/parsers/manifest_reference_resolver.py,sha256=IWUOdF03o-aQn0Occo1BJCxU0Pz-QILk5L67nzw2thw,6803
-airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py,sha256=9nlof-3xlaYC_WxOFJ5gj065DCAIxkUo1Re5FOPiTnM,151021
+airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py,sha256=Qim2qR64SKWbxD-Au0KAB3fLf6G2YfppUv3Q0w4QYtE,158619
 airbyte_cdk/sources/declarative/partition_routers/__init__.py,sha256=TBC9AkGaUqHm2IKHMPN6punBIcY5tWGULowcLoAVkfw,1109
 airbyte_cdk/sources/declarative/partition_routers/async_job_partition_router.py,sha256=VelO7zKqKtzMJ35jyFeg0ypJLQC0plqqIBNXoBW1G2E,3001
 airbyte_cdk/sources/declarative/partition_routers/cartesian_product_stream_slicer.py,sha256=c5cuVFM6NFkuQqG8Z5IwkBuwDrvXZN1CunUOM_L0ezg,6892
@@ -156,13 +156,20 @@ airbyte_cdk/sources/declarative/requesters/paginators/strategies/offset_incremen
 airbyte_cdk/sources/declarative/requesters/paginators/strategies/page_increment.py,sha256=Z2i6a-oKMmOTxHxsTVSnyaShkJ3u8xZw1xIJdx2yxss,2731
 airbyte_cdk/sources/declarative/requesters/paginators/strategies/pagination_strategy.py,sha256=ZBshGQNr5Bb_V8dqnWRISqdXFcjm1CKIXnlfbRhNl8g,1308
 airbyte_cdk/sources/declarative/requesters/paginators/strategies/stop_condition.py,sha256=LoKXdUbSgHEtSwtA8DFrnX6SpQbRVVwreY8NguTKTcI,2229
+airbyte_cdk/sources/declarative/requesters/query_properties/__init__.py,sha256=sHwHVuN6djuRBF7zQb-HmINV0By4wE5j_i6TjmIPMzQ,494
+airbyte_cdk/sources/declarative/requesters/query_properties/properties_from_endpoint.py,sha256=3h9Ae6TNGagh9sMYWdG5KoEFWDlqUWZ5fkswTPreveM,1616
+airbyte_cdk/sources/declarative/requesters/query_properties/property_chunking.py,sha256=YmUeeY3ZpsuK2VTF3SkdVuJcplI1I4UfhgzOrggifag,2748
+airbyte_cdk/sources/declarative/requesters/query_properties/query_properties.py,sha256=2VWhgphAFKmHJhzp-UoSP9_QR3eYOLPT0nzMDyglBV4,2650
+airbyte_cdk/sources/declarative/requesters/query_properties/strategies/__init__.py,sha256=ojiPj9eVU7SuNpF3RZwhZWW21IYLQYEoxpzg1rCdvNM,350
+airbyte_cdk/sources/declarative/requesters/query_properties/strategies/group_by_key.py,sha256=np4uTwSpQvXxubIzVbwSDX0Xf3EgVn8kkhs6zYLOdAQ,1081
+airbyte_cdk/sources/declarative/requesters/query_properties/strategies/merge_strategy.py,sha256=iuk9QxpwvKVtdrq9eadQVkZ-Sfk3qhyyAAErprBfw2s,516
 airbyte_cdk/sources/declarative/requesters/request_option.py,sha256=Bl0gxGWudmwT3FXBozTN00WYle2jd6ry_S1YylCnwqM,4825
 airbyte_cdk/sources/declarative/requesters/request_options/__init__.py,sha256=WCwpKqM4wKqy-DHJaCHbKAlFqRVOqMi9K5qonxIfi_Y,809
 airbyte_cdk/sources/declarative/requesters/request_options/datetime_based_request_options_provider.py,sha256=31nG6_0igidJFQon37-WeQkTpG3g2A5ZmlluI3ilZdE,3632
 airbyte_cdk/sources/declarative/requesters/request_options/default_request_options_provider.py,sha256=SRROdPJZ5kuqHLOlkh115pWP9nDGfDxRYPgH9oD3hPo,1798
 airbyte_cdk/sources/declarative/requesters/request_options/interpolated_nested_request_input_provider.py,sha256=86YozYuBDfu0t9NbevIvQoGU0vqTP4rt3dRSTsHz3PA,2269
 airbyte_cdk/sources/declarative/requesters/request_options/interpolated_request_input_provider.py,sha256=rR00kE64U2yL0McU1gPr4_W5_sLUqwDgL3Nvj691nRU,2884
-airbyte_cdk/sources/declarative/requesters/request_options/interpolated_request_options_provider.py,sha256=vOsdHfWHiTFc89WENHPv1hcxLgdzycMXVT_IEtLuhfs,5012
+airbyte_cdk/sources/declarative/requesters/request_options/interpolated_request_options_provider.py,sha256=dRlG1IyEOVzWFw7wm-8TBPn7JUtZw3jz6oAoH5yuuf0,6375
 airbyte_cdk/sources/declarative/requesters/request_options/request_options_provider.py,sha256=8YRiDzjYvqJ-aMmKFcjqzv_-e8OZ5QG_TbpZ-nuCu6s,2590
 airbyte_cdk/sources/declarative/requesters/request_path.py,sha256=S3MeFvcaQrMbOkSY2W2VbXLNomqt_3eXqVd9ZhgNwUs,299
 airbyte_cdk/sources/declarative/requesters/requester.py,sha256=OcDzuCBgD1owK_lBPG0KbRRHRn9kzbuRveU4HejDiv4,5116
@@ -173,7 +180,7 @@ airbyte_cdk/sources/declarative/resolvers/http_components_resolver.py,sha256=Aio
 airbyte_cdk/sources/declarative/retrievers/__init__.py,sha256=nQepwG_RfW53sgwvK5dLPqfCx0VjsQ83nYoPjBMAaLM,527
 airbyte_cdk/sources/declarative/retrievers/async_retriever.py,sha256=6oZtnCHm9NdDvjTSrVwPQOXGSdETSIR7eWH2vFjM7jI,4855
 airbyte_cdk/sources/declarative/retrievers/retriever.py,sha256=XPLs593Xv8c5cKMc37XzUAYmzlXd1a7eSsspM-CMuWA,1696
-airbyte_cdk/sources/declarative/retrievers/simple_retriever.py,sha256=p6O4FYS7zzPq6uQT2NVnughUjI66tePaXVlyhCAyyv0,27746
+airbyte_cdk/sources/declarative/retrievers/simple_retriever.py,sha256=Ixs_byM-DMfYiYB-iOa97yH4WGAvxgTdTYeAsskHdYM,31134
 airbyte_cdk/sources/declarative/schema/__init__.py,sha256=xU45UvM5O4c1PSM13UHpCdh5hpW3HXy9vRRGEiAC1rg,795
 airbyte_cdk/sources/declarative/schema/default_schema_loader.py,sha256=KTACrIE23a83wsm3Rd9Eb4K6-20lrGqYxTHNp9yxsso,1820
 airbyte_cdk/sources/declarative/schema/dynamic_schema_loader.py,sha256=J8Q_iJYhcSQLWyt0bTZCbDAGpxt9G8FCc6Q9jtGsNzw,10703
@@ -359,9 +366,9 @@ airbyte_cdk/utils/slice_hasher.py,sha256=EDxgROHDbfG-QKQb59m7h_7crN1tRiawdf5uU7G
 airbyte_cdk/utils/spec_schema_transformations.py,sha256=-5HTuNsnDBAhj-oLeQXwpTGA0HdcjFOf2zTEMUTTg_Y,816
 airbyte_cdk/utils/stream_status_utils.py,sha256=ZmBoiy5HVbUEHAMrUONxZvxnvfV9CesmQJLDTAIWnWw,1171
 airbyte_cdk/utils/traced_exception.py,sha256=C8uIBuCL_E4WnBAOPSxBicD06JAldoN9fGsQDp463OY,6292
-airbyte_cdk-6.44.0.dist-info/LICENSE.txt,sha256=Wfe61S4BaGPj404v8lrAbvhjYR68SHlkzeYrg3_bbuM,1051
-airbyte_cdk-6.44.0.dist-info/LICENSE_SHORT,sha256=aqF6D1NcESmpn-cqsxBtszTEnHKnlsp8L4x9wAh3Nxg,55
-airbyte_cdk-6.44.0.dist-info/METADATA,sha256=kV2dhymFTY01knD0E2Ep9U3mb92lVtiEOAix38sgyCI,6071
-airbyte_cdk-6.44.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-airbyte_cdk-6.44.0.dist-info/entry_points.txt,sha256=fj-e3PAQvsxsQzyyq8UkG1k8spunWnD4BAH2AwlR6NM,95
-airbyte_cdk-6.44.0.dist-info/RECORD,,
+airbyte_cdk-6.45.0.dist-info/LICENSE.txt,sha256=Wfe61S4BaGPj404v8lrAbvhjYR68SHlkzeYrg3_bbuM,1051
+airbyte_cdk-6.45.0.dist-info/LICENSE_SHORT,sha256=aqF6D1NcESmpn-cqsxBtszTEnHKnlsp8L4x9wAh3Nxg,55
+airbyte_cdk-6.45.0.dist-info/METADATA,sha256=QFEPcdQP0d_cCYIUW4uSBOL-muBtxr0wu7kbmc65LkQ,6071
+airbyte_cdk-6.45.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+airbyte_cdk-6.45.0.dist-info/entry_points.txt,sha256=fj-e3PAQvsxsQzyyq8UkG1k8spunWnD4BAH2AwlR6NM,95
+airbyte_cdk-6.45.0.dist-info/RECORD,,