openfeature-provider-flagd 0.2.6__tar.gz → 0.2.7__tar.gz

{openfeature_provider_flagd-0.2.6 → openfeature_provider_flagd-0.2.7}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.2.7](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd/v0.2.6...openfeature-provider-flagd/v0.2.7) (2026-01-31)
+
+
+### 🐛 Bug Fixes
+
+* **build:** bump protobuf package version to a compatible version ([#327](https://github.com/open-feature/python-sdk-contrib/issues/327)) ([223a903](https://github.com/open-feature/python-sdk-contrib/commit/223a9037cea6c7ac6b1c9bb7a159987e592ce5a4))
+
+
+### ✨ New Features
+
+* adjust to flagd metadata toggle ([#287](https://github.com/open-feature/python-sdk-contrib/issues/287)) ([6ac014d](https://github.com/open-feature/python-sdk-contrib/commit/6ac014d1af7a90b09203ae38dfd60bba275bc9a9))
+* **flagd:** Implement dual-mode selector handling (header and body) for in-process mode in python-sdk-contrib ([#320](https://github.com/open-feature/python-sdk-contrib/issues/320)) ([9ad25a4](https://github.com/open-feature/python-sdk-contrib/commit/9ad25a4ddebb91e4383b108d478288a782ede796))
+* **flagd:** support Python 3.14 for flagd ([#307](https://github.com/open-feature/python-sdk-contrib/issues/307)) ([a60b237](https://github.com/open-feature/python-sdk-contrib/commit/a60b23756fce05220201a0d0660be2a06a6807f4))
+* migrate to uv ([#293](https://github.com/open-feature/python-sdk-contrib/issues/293)) ([9590554](https://github.com/open-feature/python-sdk-contrib/commit/9590554be4c8a7f77b0c0f20d6b48076c9870f52))
+* Update python-sdk ([#289](https://github.com/open-feature/python-sdk-contrib/issues/289)) ([f2028f5](https://github.com/open-feature/python-sdk-contrib/commit/f2028f5f81824310a842507a3127a3bb9bc8a984))
+* Use time.monotonic to avoid endless loop when using time machine ([#330](https://github.com/open-feature/python-sdk-contrib/issues/330)) ([a424cdc](https://github.com/open-feature/python-sdk-contrib/commit/a424cdc68cba4dd3da28a9b18ca10ffbaf1e2689))
+
 ## [0.2.6](https://github.com/open-feature/python-sdk-contrib/compare/openfeature-provider-flagd/v0.2.5...openfeature-provider-flagd/v0.2.6) (2025-07-22)
 
 

{openfeature_provider_flagd-0.2.6 → openfeature_provider_flagd-0.2.7}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright OpenFeature Maintainers
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

openfeature_provider_flagd-0.2.7/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: openfeature-provider-flagd
+Version: 0.2.7
+Summary: OpenFeature provider for the flagd flag evaluation engine
+Project-URL: Homepage, https://github.com/open-feature/python-sdk-contrib
+Author-email: OpenFeature <openfeature-core@groups.io>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: cachebox<6.0.0,>=5.1.0
+Requires-Dist: grpcio>=1.76.0
+Requires-Dist: mmh3<6.0.0,>=5.0.0
+Requires-Dist: openfeature-sdk>=0.8.2
+Requires-Dist: panzi-json-logic>=1.0.1
+Requires-Dist: protobuf<7.0.0,>=6.30.0
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: semver<4,>=3
+Description-Content-Type: text/markdown
+
+# flagd Provider for OpenFeature
+
+This provider is designed to use flagd's [evaluation protocol](https://github.com/open-feature/schemas/blob/main/protobuf/schema/v1/schema.proto), or locally evaluate flags defined in a flagd [flag definition](https://github.com/open-feature/schemas/blob/main/json/flagd-definitions.json) via the OpenFeature Python SDK.
+
+## Installation
+
+```
+pip install openfeature-provider-flagd
+```
+
+## Configuration and Usage
+
+The flagd provider can operate in two modes: [RPC](#remote-resolver-rpc) (evaluation takes place in flagd, via gRPC calls) or [in-process](#in-process-resolver) (evaluation takes place in-process, with the provider getting a ruleset from a compliant sync-source).
+
+### Remote resolver (RPC)
+
+This is the default mode of operation of the provider.
+In this mode, `FlagdProvider` communicates with [flagd](https://github.com/open-feature/flagd) via the gRPC protocol.
+Flag evaluations take place remotely at the connected flagd instance.
+
+Instantiate a new FlagdProvider instance and configure the OpenFeature SDK to use it:
+
+```python
+from openfeature import api
+from openfeature.contrib.provider.flagd import FlagdProvider
+
+api.set_provider(FlagdProvider())
+```
+
+### In-process resolver
+
+This mode performs flag evaluations locally (in-process). Flag configurations for evaluation are obtained via gRPC protocol using [sync protobuf schema](https://buf.build/open-feature/flagd/file/main:sync/v1/sync_service.proto) service definition.
+
+Consider the following example to create a `FlagdProvider` with in-process evaluations,
+
+```python
+from openfeature import api
+from openfeature.contrib.provider.flagd import FlagdProvider
+from openfeature.contrib.provider.flagd.config import ResolverType
+
+api.set_provider(FlagdProvider(
+    resolver_type=ResolverType.IN_PROCESS,
+))
+```
+
+In the above example, in-process handlers attempt to connect to a sync service on address `localhost:8013` to obtain [flag definitions](https://github.com/open-feature/schemas/blob/main/json/flags.json).
+
+<!--
+#### Sync-metadata
+
+To support the injection of contextual data configured in flagd for in-process evaluation, the provider exposes a `getSyncMetadata` accessor which provides the most recent value returned by the [GetMetadata RPC](https://buf.build/open-feature/flagd/docs/main:flagd.sync.v1#flagd.sync.v1.FlagSyncService.GetMetadata).
+The value is updated with every (re)connection to the sync implementation.
+This can be used to enrich evaluations with such data.
+If the `in-process` mode is not used, and before the provider is ready, the `getSyncMetadata` returns an empty map.
+-->
+### File mode
+
+In-process resolvers can also work in an offline mode.
+To enable this mode, you should provide a valid flag configuration file with the option `offlineFlagSourcePath`.
+
+```python
+from openfeature import api
+from openfeature.contrib.provider.flagd import FlagdProvider
+from openfeature.contrib.provider.flagd.config import ResolverType
+
+api.set_provider(FlagdProvider(
+    resolver_type=ResolverType.FILE,
+    offline_flag_source_path="my-flag.json",
+))
+```
+
+Provider will attempt to detect file changes using polling.
+Polling happens at 5 second intervals and this is currently unconfigurable.
+This mode is useful for local development, tests and offline applications.
+
+### Configuration options
+
+The default options can be defined in the FlagdProvider constructor.
+
+| Option name              | Environment variable name      | Type & Values              | Default                       | Compatible resolver |
+|--------------------------|--------------------------------|----------------------------|-------------------------------|---------------------|
+| resolver_type            | FLAGD_RESOLVER                 | enum - `rpc`, `in-process` | rpc                           |                     |
+| host                     | FLAGD_HOST                     | str                        | localhost                     | rpc & in-process    |
+| port                     | FLAGD_PORT                     | int                        | 8013 (rpc), 8015 (in-process) | rpc & in-process    |
+| tls                      | FLAGD_TLS                      | bool                       | false                         | rpc & in-process    |
+| cert_path                | FLAGD_SERVER_CERT_PATH         | String                     | null                          | rpc & in-process    |
+| deadline                 | FLAGD_DEADLINE_MS              | int                        | 500                           | rpc & in-process    |
+| stream_deadline_ms       | FLAGD_STREAM_DEADLINE_MS       | int                        | 600000                        | rpc & in-process    |
+| keep_alive_time          | FLAGD_KEEP_ALIVE_TIME_MS       | int                        | 0                             | rpc & in-process    |
+| selector                 | FLAGD_SOURCE_SELECTOR          | str                        | null                          | in-process          |
+| cache_type               | FLAGD_CACHE                    | enum - `lru`, `disabled`   | lru                           | rpc                 |
+| max_cache_size           | FLAGD_MAX_CACHE_SIZE           | int                        | 1000                          | rpc                 |
+| retry_backoff_ms         | FLAGD_RETRY_BACKOFF_MS         | int                        | 1000                          | rpc                 |
+| offline_flag_source_path | FLAGD_OFFLINE_FLAG_SOURCE_PATH | str                        | null                          | in-process          |
+
+> [!NOTE]
+> The `selector` configuration is only used in **in-process** mode for filtering flag configurations. See [Selector Handling](#selector-handling-in-process-mode-only) for migration guidance.
+
+<!-- not implemented
+| target_uri               | FLAGD_TARGET_URI               | alternative to host/port, supporting custom name resolution | string    | null                | rpc & in-process |
+| socket_path              | FLAGD_SOCKET_PATH              | alternative to host port, unix socket                       | String    | null                | rpc & in-process |
+| context_enricher         | -                              | sync-metadata to evaluation context mapping function        | function  | identity function   | in-process       |
+| offline_pollIntervalMs   | FLAGD_OFFLINE_POLL_MS          | poll interval for reading offlineFlagSourcePath             | int       | 5000                | in-process       |
+ -->
+
+> [!NOTE]
+> Some configurations are only applicable for RPC resolver.
+
+### Selector Handling (In-Process Mode Only)
+
+> [!IMPORTANT]
+> This section only applies to **in-process** resolver mode. RPC mode is not affected by selector handling changes.
+
+#### Current Implementation
+
+As of this SDK version, the `selector` parameter is passed via **both** gRPC metadata headers (`flagd-selector`) and the request body when using in-process mode. This dual approach ensures maximum compatibility with all flagd versions.
+
+**Configuration Example:**
+```python
+from openfeature import api
+from openfeature.contrib.provider.flagd import FlagdProvider
+from openfeature.contrib.provider.flagd.config import ResolverType
+
+api.set_provider(FlagdProvider(
+    resolver_type=ResolverType.IN_PROCESS,
+    selector="my-flag-source",  # Passed via both header and request body
+))
+```
+
+The selector is automatically passed via:
+- **gRPC metadata header** (`flagd-selector`) - For flagd v0.11.0+ selector normalization
+- **Request body** - For backward compatibility with older flagd versions
+
+#### Backward Compatibility
+
+This dual transmission approach ensures the Python SDK works seamlessly with all flagd service versions:
+- **Older flagd versions** read the selector from the request body
+- **Newer flagd versions (v0.11.0+)** prefer the selector from the gRPC metadata header
+- Both approaches are supported simultaneously for maximum compatibility
+
+**Related Resources:**
+- Upstream issue: [open-feature/flagd#1814](https://github.com/open-feature/flagd/issues/1814)
+- Selector normalization affects in-process evaluations that filter flag configurations by source
+
+<!--
+### Unix socket support
+Unix socket communication with flagd is facilitated by usaging of the linux-native `epoll` library on `linux-x86_64`
+only (ARM support is pending the release of `netty-transport-native-epoll` v5).
+Unix sockets are not supported on other platforms or architectures.
+-->
+
+### Reconnection
+
+Reconnection is supported by the underlying gRPC connections.
+If the connection to flagd is lost, it will reconnect automatically.
+A failure to connect will result in an [error event](https://openfeature.dev/docs/reference/concepts/events#provider_error) from the provider, though it will attempt to reconnect indefinitely.
+
+### Deadlines
+
+Deadlines are used to define how long the provider waits to complete initialization or flag evaluations.
+They behave differently based on the resolver type.
+
+#### Deadlines with Remote resolver (RPC)
+
+If the remote evaluation call is not completed within this deadline, the gRPC call is terminated with the error `DEADLINE_EXCEEDED`
+and the evaluation will default.
+
+### TLS
+
+TLS is available in situations where flagd is running on another host.
+
+
+You may optionally supply an X.509 certificate in PEM format. Otherwise, the default certificate store will be used.
+
+```python
+from openfeature import api
+from openfeature.contrib.provider.flagd import FlagdProvider
+
+api.set_provider(FlagdProvider(
+    tls=True,                        # use TLS
+    cert_path="etc/cert/ca.crt"      # PEM cert
+))
+```
+
+## License
+
+Apache 2.0 - See [LICENSE](./LICENSE) for more information.

{openfeature_provider_flagd-0.2.6 → openfeature_provider_flagd-0.2.7}/README.md

@@ -93,6 +93,9 @@ The default options can be defined in the FlagdProvider constructor.
 | retry_backoff_ms         | FLAGD_RETRY_BACKOFF_MS         | int                        | 1000                          | rpc                 |
 | offline_flag_source_path | FLAGD_OFFLINE_FLAG_SOURCE_PATH | str                        | null                          | in-process          |
 
+> [!NOTE]
+> The `selector` configuration is only used in **in-process** mode for filtering flag configurations. See [Selector Handling](#selector-handling-in-process-mode-only) for migration guidance.
+
 <!-- not implemented
 | target_uri               | FLAGD_TARGET_URI               | alternative to host/port, supporting custom name resolution | string    | null                | rpc & in-process |
 | socket_path              | FLAGD_SOCKET_PATH              | alternative to host port, unix socket                       | String    | null                | rpc & in-process |
@@ -103,6 +106,42 @@ The default options can be defined in the FlagdProvider constructor.
 > [!NOTE]
 > Some configurations are only applicable for RPC resolver.
 
+### Selector Handling (In-Process Mode Only)
+
+> [!IMPORTANT]
+> This section only applies to **in-process** resolver mode. RPC mode is not affected by selector handling changes.
+
+#### Current Implementation
+
+As of this SDK version, the `selector` parameter is passed via **both** gRPC metadata headers (`flagd-selector`) and the request body when using in-process mode. This dual approach ensures maximum compatibility with all flagd versions.
+
+**Configuration Example:**
+```python
+from openfeature import api
+from openfeature.contrib.provider.flagd import FlagdProvider
+from openfeature.contrib.provider.flagd.config import ResolverType
+
+api.set_provider(FlagdProvider(
+    resolver_type=ResolverType.IN_PROCESS,
+    selector="my-flag-source",  # Passed via both header and request body
+))
+```
+
+The selector is automatically passed via:
+- **gRPC metadata header** (`flagd-selector`) - For flagd v0.11.0+ selector normalization
+- **Request body** - For backward compatibility with older flagd versions
+
+#### Backward Compatibility
+
+This dual transmission approach ensures the Python SDK works seamlessly with all flagd service versions:
+- **Older flagd versions** read the selector from the request body
+- **Newer flagd versions (v0.11.0+)** prefer the selector from the gRPC metadata header
+- Both approaches are supported simultaneously for maximum compatibility
+
+**Related Resources:**
+- Upstream issue: [open-feature/flagd#1814](https://github.com/open-feature/flagd/issues/1814)
+- Selector normalization affects in-process evaluations that filter flag configurations by source
+
 <!--
 ### Unix socket support
 Unix socket communication with flagd is facilitated by usaging of the linux-native `epoll` library on `linux-x86_64`

{openfeature_provider_flagd-0.2.6 → openfeature_provider_flagd-0.2.7}/pyproject.toml

@@ -1,83 +1,54 @@
-# pyproject.toml
 [build-system]
+# `uv_build` backend doesn't support build hooks yet https://github.com/astral-sh/uv/issues/14561
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [project]
 name = "openfeature-provider-flagd"
-version = "0.2.6"
+version = "0.2.7"
 description = "OpenFeature provider for the flagd flag evaluation engine"
 readme = "README.md"
 authors = [{ name = "OpenFeature", email = "openfeature-core@groups.io" }]
-license = { file = "LICENSE" }
+license = "Apache-2.0"
+license-files = ["LICENSE"]
 classifiers = [
-    "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
 ]
 keywords = []
 dependencies = [
-  "openfeature-sdk>=0.6.0",
-  "grpcio>=1.68.1",
-  "protobuf>=5.26.1",
-  "mmh3>=4.1.0",
+  "openfeature-sdk>=0.8.2",
+  "grpcio>=1.76.0",
+  "protobuf>=6.30.0,<7.0.0",
+  "mmh3>=5.0.0,<6.0.0",
   "panzi-json-logic>=1.0.1",
   "semver>=3,<4",
   "pyyaml>=6.0.1",
-  "cachebox"
+  "cachebox>=5.1.0,<6.0.0",
 ]
 requires-python = ">=3.9"
 
 [project.urls]
 Homepage = "https://github.com/open-feature/python-sdk-contrib"
 
-[tool.hatch]
-
-[tool.hatch.envs.hatch-test]
-dependencies = [
-  "coverage[toml]>=6.5",
-  "pytest",
-  "pytest-bdd",
-  "testcontainers",
-  "asserts",
-  "grpcio-health-checking",
+[dependency-groups]
+dev = [
+  "asserts>=0.13.0,<0.14.0",
+  "coverage[toml]>=7.10.0,<8.0.0",
+  "grpcio-health-checking>=1.74.0,<2.0.0",
+  "mypy>=1.18.0,<2.0.0",
+  "pytest>=8.4.0,<9.0.0",
+  "pytest-bdd>=8.1.0,<9.0.0",
+  "testcontainers>=4.12.0,<5.0.0",
+  "types-grpcio>=1.0.0,<2.0.0",
+  "types-protobuf>=6.30.0,<7.0.0",
+  "types-pyyaml>=6.0.0,<7.0.0",
 ]
-pre-install-commands = [
-  "hatch build",
-]
-
-[tool.hatch.envs.hatch-test.scripts]
-run = "pytest {args:tests}"
-run-cov = "coverage run -m pytest {args:tests}"
-cov-combine = "coverage combine"
-cov-report = [
-  "coverage xml",
-  "coverage html",
-  "coverage report",
-]
-cov = [
-  "test-cov",
-  "cov-report",
-]
-
-
-[tool.hatch.envs.mypy]
-dependencies = [
-  "mypy[faster-cache]>=1.13.0",
-  "types-protobuf",
-  "types-pyyaml",
-]
-pre-install-commands = [
-  "hatch build",
-]
-
-[tool.hatch.envs.mypy.scripts]
-run = "mypy"
 
 [tool.hatch.build.hooks.protobuf]
 generate_pyi = false
 dependencies = [
-    "protobuf==5.26.1",
+    "protobuf~=6.0",
     "hatch-protobuf",
     "mypy-protobuf~=3.0",
 ]
@@ -117,7 +88,9 @@ files = "src"
 python_version = "3.9" # should be identical to the minimum supported version
 namespace_packages = true
 explicit_package_bases = true
-local_partial_types = true
+local_partial_types = true # will become the new default from version 2
+allow_redefinition_new = true # will become the new default from version 2
+fixed_format_cache = true # new caching mechanism
 pretty = true
 
 strict = true
@@ -125,7 +98,6 @@ disallow_any_generics = false
 
 [[tool.mypy.overrides]]
 module = [
-    "grpc.*",
     "json_logic.*",
 ]
 ignore_missing_imports = true
@@ -135,3 +107,13 @@ module = [
     "openfeature.schemas.*"
 ]
 warn_unused_ignores = false
+
+[project.scripts]
+# workaround while UV doesn't support scripts directly in the pyproject.toml
+# see: https://github.com/astral-sh/uv/issues/5903
+cov-report = "scripts.scripts:cov_report"
+cov = "scripts.scripts:cov"
+# don't name it `mypy` otherwise `uv` will override the actual binary
+mypy-check = "scripts.scripts:mypy"
+test = "scripts.scripts:test"
+test-cov = "scripts.scripts:test_cov"

{openfeature_provider_flagd-0.2.6 → openfeature_provider_flagd-0.2.7}/src/openfeature/contrib/provider/flagd/provider.py

@@ -28,7 +28,7 @@ import grpc
 
 from openfeature.evaluation_context import EvaluationContext
 from openfeature.event import ProviderEventDetails
-from openfeature.flag_evaluation import FlagResolutionDetails
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagValueType
 from openfeature.hook import Hook
 from openfeature.provider import AbstractProvider
 from openfeature.provider.metadata import Metadata
@@ -75,6 +75,9 @@ class FlagdProvider(AbstractProvider):
         :param deadline_ms: the maximum to wait before a request times out
         :param timeout: the maximum time to wait before a request times out
         :param retry_backoff_ms: the number of milliseconds to backoff
+        :param selector: filter flag configurations by source (in-process mode only)
+                         Passed via both flagd-selector gRPC metadata header and request body
+                         for backward compatibility with all flagd versions.
         :param offline_flag_source_path: the path to the flag source file
         :param stream_deadline_ms: the maximum time to wait before a request times out
         :param keep_alive_time: the number of milliseconds to keep alive
@@ -199,9 +202,13 @@ class FlagdProvider(AbstractProvider):
     def resolve_object_details(
         self,
         flag_key: str,
-        default_value: typing.Union[dict, list],
+        default_value: typing.Union[
+            typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]
+        ],
         evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+    ) -> FlagResolutionDetails[
+        typing.Union[typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]]
+    ]:
         return self.resolver.resolve_object_details(
             flag_key, default_value, evaluation_context
         )

{openfeature_provider_flagd-0.2.6 → openfeature_provider_flagd-0.2.7}/src/openfeature/contrib/provider/flagd/resolvers/grpc.py

@@ -21,7 +21,7 @@ from openfeature.exception import (
     ProviderNotReadyError,
     TypeMismatchError,
 )
-from openfeature.flag_evaluation import FlagResolutionDetails, Reason
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagValueType, Reason
 from openfeature.schemas.protobuf.flagd.evaluation.v1 import (
     evaluation_pb2,
     evaluation_pb2_grpc,
@@ -29,6 +29,7 @@ from openfeature.schemas.protobuf.flagd.evaluation.v1 import (
 
 from ..config import CacheType, Config
 from ..flag_type import FlagType
+from .types import GrpcMultiCallableArgs
 
 if typing.TYPE_CHECKING:
     from google.protobuf.message import Message
@@ -71,8 +72,6 @@ class GrpcResolver:
         self.thread: typing.Optional[threading.Thread] = None
         self.timer: typing.Optional[threading.Timer] = None
 
-        self.start_time = time.time()
-
     def _generate_channel(self, config: Config) -> grpc.Channel:
         target = f"{config.host}:{config.port}"
         # Create the channel with the service config
@@ -121,15 +120,16 @@ class GrpcResolver:
             ),
         ]
         if config.tls:
-            channel_args = {
-                "options": options,
-                "credentials": grpc.ssl_channel_credentials(),
-            }
+            credentials = grpc.ssl_channel_credentials()
             if config.cert_path:
                 with open(config.cert_path, "rb") as f:
-                    channel_args["credentials"] = grpc.ssl_channel_credentials(f.read())
+                    credentials = grpc.ssl_channel_credentials(f.read())
 
-            channel = grpc.secure_channel(target, **channel_args)
+            channel = grpc.secure_channel(
+                target,
+                credentials=credentials,
+                options=options,
+            )
 
         else:
             channel = grpc.insecure_channel(
@@ -161,8 +161,8 @@ class GrpcResolver:
         )
         self.monitor_thread.start()
         ## block until ready or deadline reached
-        timeout = self.deadline + time.time()
-        while not self.connected and time.time() < timeout:
+        timeout = self.deadline + time.monotonic()
+        while not self.connected and time.monotonic() < timeout:
             time.sleep(0.05)
         logger.debug("Finished blocking gRPC state initialization")
 
@@ -199,7 +199,6 @@ class GrpcResolver:
                     message="gRPC sync disconnected, reconnecting",
                 )
             )
-            self.start_time = time.time()
             # adding a timer, so we can emit the error event after time
             self.timer = threading.Timer(self.retry_grace_period, self.emit_error)
 
@@ -220,20 +219,16 @@ class GrpcResolver:
 
     def listen(self) -> None:
         logger.debug("gRPC starting listener thread")
-        call_args = (
-            {"timeout": self.streamline_deadline_seconds}
-            if self.streamline_deadline_seconds > 0
-            else {}
-        )
+        call_args: GrpcMultiCallableArgs = {"wait_for_ready": True}
+        if self.streamline_deadline_seconds > 0:
+            call_args["timeout"] = self.streamline_deadline_seconds
         request = evaluation_pb2.EventStreamRequest()
 
         # defining a never ending loop to recreate the stream
         while self.active:
             try:
                 logger.debug("Setting up gRPC sync flags connection")
-                for message in self.stub.EventStream(
-                    request, wait_for_ready=True, **call_args
-                ):
+                for message in self.stub.EventStream(request, **call_args):
                     if message.type == "provider_ready":
                         self.emit_provider_ready(
                             ProviderEventDetails(
@@ -300,25 +295,81 @@ class GrpcResolver:
     def resolve_object_details(
         self,
         key: str,
-        default_value: typing.Union[dict, list],
+        default_value: typing.Union[
+            typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]
+        ],
         evaluation_context: typing.Optional[EvaluationContext] = None,
-    ) -> FlagResolutionDetails[typing.Union[dict, list]]:
+    ) -> FlagResolutionDetails[
+        typing.Union[typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]]
+    ]:
         return self._resolve(key, FlagType.OBJECT, default_value, evaluation_context)
 
+    @typing.overload
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: bool,
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[bool]: ...
+
+    @typing.overload
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: int,
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[int]: ...
+
+    @typing.overload
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: float,
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[float]: ...
+
+    @typing.overload
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: str,
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[str]: ...
+
+    @typing.overload
+    def _resolve(
+        self,
+        flag_key: str,
+        flag_type: FlagType,
+        default_value: typing.Union[
+            typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]
+        ],
+        evaluation_context: typing.Optional[EvaluationContext],
+    ) -> FlagResolutionDetails[
+        typing.Union[typing.Sequence[FlagValueType], typing.Mapping[str, FlagValueType]]
+    ]: ...
+
     def _resolve(  # noqa: PLR0915 C901
         self,
         flag_key: str,
         flag_type: FlagType,
-        default_value: T,
+        default_value: FlagValueType,
         evaluation_context: typing.Optional[EvaluationContext],
-    ) -> FlagResolutionDetails[T]:
+    ) -> FlagResolutionDetails[FlagValueType]:
         if self.cache is not None and flag_key in self.cache:
-            cached_flag: FlagResolutionDetails[T] = self.cache[flag_key]
+            cached_flag: FlagResolutionDetails[FlagValueType] = self.cache[flag_key]
             cached_flag.reason = Reason.CACHED
             return cached_flag
 
         context = self._convert_context(evaluation_context)
-        call_args = {"timeout": self.deadline, "wait_for_ready": True}
+        call_args: GrpcMultiCallableArgs = {
+            "timeout": self.deadline,
+            "wait_for_ready": True,
+        }
         try:
             request: Message
             if flag_type == FlagType.BOOLEAN:
@@ -387,7 +438,11 @@ class GrpcResolver:
         if evaluation_context:
             try:
                 s["targetingKey"] = evaluation_context.targeting_key
-                s.update(evaluation_context.attributes)
+                s.update(
+                    typing.cast(
+                        "typing.Mapping[str, typing.Any]", evaluation_context.attributes
+                    )
+                )
             except ValueError as exc:
                 message = (
                     "could not serialize evaluation context to google.protobuf.Struct"