digitalkin 0.3.0rc1__py3-none-any.whl → 0.3.1__py3-none-any.whl

digitalkin/grpc_servers/module_servicer.py

@@ -5,7 +5,7 @@ from collections.abc import AsyncGenerator
 from typing import Any
 
 import grpc
-from digitalkin_proto.digitalkin.module.v2 import (
+from digitalkin_proto.agentic_mesh_protocol.module.v1 import (
     information_pb2,
     lifecycle_pb2,
     module_service_pb2_grpc,
@@ -112,7 +112,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # TODO: Secret should be used here as well
         setup_version = request.setup_version
         config_setup_data = self.module_class.create_config_setup_model(json_format.MessageToDict(request.content))
-        setup_version_data = self.module_class.create_setup_model(
+        setup_version_data = await self.module_class.create_setup_model(
             json_format.MessageToDict(request.setup_version.content),
             config_fields=True,
         )
@@ -172,7 +172,8 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         )
         # Process the module input
         # TODO: Check failure of input data format
-        input_data = self.module_class.create_input_model(dict(request.input.items()))
+        input_data = self.module_class.create_input_model(json_format.MessageToDict(request.input))
+
         setup_data_class = self.setup.get_setup(
             setup_dict={
                 "setup_id": request.setup_id,
@@ -184,7 +185,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
             msg = "No setup data returned."
             raise ServicerError(msg)
 
-        setup_data = self.module_class.create_setup_model(setup_data_class.current_setup_version.content)
+        setup_data = await self.module_class.create_setup_model(setup_data_class.current_setup_version.content)
 
         # create a task to run the module in background
         job_id = await self.job_manager.create_module_instance_job(
@@ -219,13 +220,17 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
                         break
 
                     if message.get("code", None) is not None and message.get("code") == "__END_OF_STREAM__":
-                        yield lifecycle_pb2.StartModuleResponse(success=True, job_id=job_id)
+                        logger.info(
+                            "End of stream via __END_OF_STREAM__",
+                            extra={"job_id": job_id, "mission_id": request.mission_id},
+                        )
                         break
 
+                    logger.info("Yielding message from job %s: %s", job_id, message)
                     proto = json_format.ParseDict(message, struct_pb2.Struct(), ignore_unknown_fields=True)
                     yield lifecycle_pb2.StartModuleResponse(success=True, output=proto, job_id=job_id)
         finally:
-            await self.job_manager.tasks[job_id]
+            await self.job_manager.wait_for_completion(job_id)
             await self.job_manager.clean_session(job_id, mission_id=request.mission_id)
 
         logger.info("Job %s finished", job_id)
@@ -345,7 +350,9 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # Get input schema if available
         try:
             # Convert schema to proto format
-            input_schema_proto = self.module_class.get_input_format(llm_format=request.llm_format)
+            input_schema_proto = await self.module_class.get_input_format(
+                llm_format=request.llm_format,
+            )
             input_format_struct = json_format.Parse(
                 text=input_schema_proto,
                 message=struct_pb2.Struct(),  # pylint: disable=no-member
@@ -381,7 +388,9 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # Get output schema if available
         try:
             # Convert schema to proto format
-            output_schema_proto = self.module_class.get_output_format(llm_format=request.llm_format)
+            output_schema_proto = await self.module_class.get_output_format(
+                llm_format=request.llm_format,
+            )
             output_format_struct = json_format.Parse(
                 text=output_schema_proto,
                 message=struct_pb2.Struct(),  # pylint: disable=no-member
@@ -417,7 +426,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # Get setup schema if available
         try:
             # Convert schema to proto format
-            setup_schema_proto = self.module_class.get_setup_format(llm_format=request.llm_format)
+            setup_schema_proto = await self.module_class.get_setup_format(llm_format=request.llm_format)
             setup_format_struct = json_format.Parse(
                 text=setup_schema_proto,
                 message=struct_pb2.Struct(),  # pylint: disable=no-member
@@ -434,7 +443,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
             setup_schema=setup_format_struct,
         )
 
-    def GetModuleSecret(  # noqa: N802
+    async def GetModuleSecret(  # noqa: N802
         self,
         request: information_pb2.GetModuleSecretRequest,
         context: grpc.ServicerContext,
@@ -453,7 +462,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # Get secret schema if available
         try:
             # Convert schema to proto format
-            secret_schema_proto = self.module_class.get_secret_format(llm_format=request.llm_format)
+            secret_schema_proto = await self.module_class.get_secret_format(llm_format=request.llm_format)
             secret_format_struct = json_format.Parse(
                 text=secret_schema_proto,
                 message=struct_pb2.Struct(),  # pylint: disable=no-member
@@ -489,7 +498,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # Get setup schema if available
         try:
             # Convert schema to proto format
-            config_setup_schema_proto = self.module_class.get_config_setup_format(llm_format=request.llm_format)
+            config_setup_schema_proto = await self.module_class.get_config_setup_format(llm_format=request.llm_format)
             config_setup_format_struct = json_format.Parse(
                 text=config_setup_schema_proto,
                 message=struct_pb2.Struct(),  # pylint: disable=no-member

digitalkin/grpc_servers/registry_server.py

@@ -1,6 +1,6 @@
 """Registry gRPC server implementation for DigitalKin."""
 
-from digitalkin_proto.digitalkin.module_registry.v2 import (
+from digitalkin_proto.agentic_mesh_protocol.module_registry.v1 import (
     module_registry_service_pb2,
     module_registry_service_pb2_grpc,
 )

digitalkin/grpc_servers/registry_servicer.py

@@ -9,7 +9,7 @@ from collections.abc import Iterator
 from enum import Enum
 
 import grpc
-from digitalkin_proto.digitalkin.module_registry.v2 import (
+from digitalkin_proto.agentic_mesh_protocol.module_registry.v1 import (
     discover_pb2,
     metadata_pb2,
     module_registry_service_pb2_grpc,
@@ -344,7 +344,7 @@ class RegistryServicer(module_registry_service_pb2_grpc.ModuleRegistryServiceSer
             return status_pb2.ModuleStatusResponse()
 
         module = self.registered_modules[request.module_id]
-        return status_pb2.ModuleStatusResponse(module_id=module.module_id, status=module.status.name)
+        return status_pb2.ModuleStatusResponse(module_id=module.module_id, status=module.status.value)
 
     def ListModuleStatus(  # noqa: N802
         self,
@@ -379,7 +379,7 @@ class RegistryServicer(module_registry_service_pb2_grpc.ModuleRegistryServiceSer
             list_size = len(self.registered_modules)
 
         modules_statuses = [
-            status_pb2.ModuleStatusResponse(module_id=module.module_id, status=module.status.name)
+            status_pb2.ModuleStatusResponse(module_id=module.module_id, status=module.status.value)
             for module in list(self.registered_modules.values())[request.offset : request.offset + list_size]
         ]
 
@@ -409,7 +409,7 @@ class RegistryServicer(module_registry_service_pb2_grpc.ModuleRegistryServiceSer
         for module in self.registered_modules.values():
             yield status_pb2.ModuleStatusResponse(
                 module_id=module.module_id,
-                status=module.status.name,
+                status=module.status.value,
             )
 
     def UpdateModuleStatus(  # noqa: N802

digitalkin/grpc_servers/utils/grpc_error_handler.py

@@ -0,0 +1,53 @@
+"""Shared error handling utilities for gRPC services."""
+
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any
+
+from digitalkin.grpc_servers.utils.exceptions import ServerError
+from digitalkin.logger import logger
+
+
+class GrpcErrorHandlerMixin:
+    """Mixin class providing common gRPC error handling functionality."""
+
+    @contextmanager
+    def handle_grpc_errors(  # noqa: PLR6301
+        self,
+        operation: str,
+        service_error_class: type[Exception] | None = None,
+    ) -> Generator[Any, Any, Any]:
+        """Handle gRPC errors for the given operation.
+
+        Args:
+            operation: Name of the operation being performed.
+            service_error_class: Optional specific service exception class to raise.
+                                If not provided, uses the generic ServerError.
+
+        Yields:
+            Context for the operation.
+
+        Raises:
+            ServerError: For gRPC-related errors.
+            service_error_class: For service-specific errors if provided.
+        """
+        if service_error_class is None:
+            service_error_class = ServerError
+
+        try:
+            yield
+        except service_error_class as e:
+            # Re-raise service-specific errors as-is
+            msg = f"{service_error_class.__name__} in {operation}: {e}"
+            logger.exception(msg)
+            raise service_error_class(msg) from e
+        except ServerError as e:
+            # Handle gRPC server errors
+            msg = f"gRPC {operation} failed: {e}"
+            logger.exception(msg)
+            raise ServerError(msg) from e
+        except Exception as e:
+            # Handle unexpected errors
+            msg = f"Unexpected error in {operation}: {e}"
+            logger.exception(msg)
+            raise service_error_class(msg) from e

digitalkin/models/core/task_monitor.py

@@ -17,6 +17,23 @@ class TaskStatus(Enum):
     FAILED = "failed"
 
 
+class CancellationReason(Enum):
+    """Reason for task cancellation - helps distinguish cleanup vs real cancellation."""
+
+    # Cleanup cancellations (not errors)
+    SUCCESS_CLEANUP = "success_cleanup"  # Main task completed, cleaning up helper tasks
+    FAILURE_CLEANUP = "failure_cleanup"  # Main task failed, cleaning up helper tasks
+
+    # Real cancellations
+    SIGNAL = "signal"  # External signal requested cancellation
+    HEARTBEAT_FAILURE = "heartbeat_failure"  # Heartbeat stopped working
+    TIMEOUT = "timeout"  # Task timed out
+    SHUTDOWN = "shutdown"  # Manager is shutting down
+
+    # Unknown/unset
+    UNKNOWN = "unknown"  # Reason not determined
+
+
 class SignalType(Enum):
     """Signal type enumeration."""
 

digitalkin/models/grpc_servers/models.py

@@ -175,8 +175,8 @@ class ClientConfig(ChannelConfig):
     credentials: ClientCredentials | None = Field(None, description="Client credentials for secure mode")
     channel_options: list[tuple[str, Any]] = Field(
         default_factory=lambda: [
-            ("grpc.max_receive_message_length", 50 * 1024 * 1024),  # 50MB
-            ("grpc.max_send_message_length", 50 * 1024 * 1024),  # 50MB
+            ("grpc.max_receive_message_length", 100 * 1024 * 1024),  # 100MB
+            ("grpc.max_send_message_length", 100 * 1024 * 1024),  # 100MB
         ],
         description="Additional channel options",
     )
@@ -223,8 +223,8 @@ class ServerConfig(ChannelConfig):
     credentials: ServerCredentials | None = Field(None, description="Server credentials for secure mode")
     server_options: list[tuple[str, Any]] = Field(
         default_factory=lambda: [
-            ("grpc.max_receive_message_length", 50 * 1024 * 1024),  # 50MB
-            ("grpc.max_send_message_length", 50 * 1024 * 1024),  # 50MB
+            ("grpc.max_receive_message_length", 100 * 1024 * 1024),  # 100MB
+            ("grpc.max_send_message_length", 100 * 1024 * 1024),  # 100MB
         ],
         description="Additional server options",
     )

digitalkin/models/module/module_context.py

@@ -10,6 +10,7 @@ from digitalkin.services.identity.identity_strategy import IdentityStrategy
 from digitalkin.services.registry.registry_strategy import RegistryStrategy
 from digitalkin.services.snapshot.snapshot_strategy import SnapshotStrategy
 from digitalkin.services.storage.storage_strategy import StorageStrategy
+from digitalkin.services.user_profile.user_profile_strategy import UserProfileStrategy
 
 
 class Session(SimpleNamespace):
@@ -89,6 +90,7 @@ class ModuleContext:
     registry: RegistryStrategy
     snapshot: SnapshotStrategy
     storage: StorageStrategy
+    user_profile: UserProfileStrategy
 
     session: Session
     callbacks: SimpleNamespace
@@ -105,6 +107,7 @@ class ModuleContext:
         registry: RegistryStrategy,
         snapshot: SnapshotStrategy,
         storage: StorageStrategy,
+        user_profile: UserProfileStrategy,
         session: dict[str, Any],
         metadata: dict[str, Any] = {},
         helpers: dict[str, Any] = {},
@@ -120,6 +123,7 @@ class ModuleContext:
             registry: RegistryStrategy.
             snapshot: SnapshotStrategy.
             storage: StorageStrategy.
+            user_profile: UserProfileStrategy.
             metadata: dict defining differents Module metadata.
             helpers: dict different user defined helpers.
             session: dict referring the session IDs or informations.
@@ -133,6 +137,7 @@ class ModuleContext:
         self.registry = registry
         self.snapshot = snapshot
         self.storage = storage
+        self.user_profile = user_profile
 
         self.metadata = SimpleNamespace(**metadata)
         self.session = Session(**session)

digitalkin/models/module/module_types.py

@@ -1,11 +1,25 @@
 """Types for module models."""
 
+from __future__ import annotations
+
+import copy
+import types
+import typing
 from datetime import datetime, timezone
-from typing import Any, ClassVar, Generic, TypeVar, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar, cast, get_args, get_origin
 
 from pydantic import BaseModel, ConfigDict, Field, create_model
 
 from digitalkin.logger import logger
+from digitalkin.utils.dynamic_schema import (
+    DynamicField,
+    get_fetchers,
+    has_dynamic,
+    resolve_safe,
+)
+
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
 
 
 class DataTrigger(BaseModel):
@@ -24,7 +38,11 @@ class DataTrigger(BaseModel):
     """
 
     protocol: ClassVar[str]
-    created_at: str = datetime.now(tz=timezone.utc).isoformat()
+    created_at: str = Field(
+        default_factory=lambda: datetime.now(tz=timezone.utc).isoformat(),
+        title="Created At",
+        description="Timestamp when the payload was created.",
+    )
 
 
 DataTriggerT = TypeVar("DataTriggerT", bound=DataTrigger)
@@ -57,27 +75,50 @@ SetupModelT = TypeVar("SetupModelT", bound="SetupModel")
 class SetupModel(BaseModel):
     """Base definition of setup model showing mandatory root fields.
 
-    Optionally, the setup model can define a config option in json_schema_extra to be used to initialize the Kin.
+    Optionally, the setup model can define a config option in json_schema_extra
+    to be used to initialize the Kin. Supports dynamic schema providers for
+    runtime value generation.
 
-    Example:
-        class MySetup(SetupModel):
-            name: str = Field()
-            number: int = Field(..., json_schema_extra={"config": True})
+    Attributes:
+        model_fields: Inherited from Pydantic BaseModel, contains field definitions.
+
+    See Also:
+        - Documentation: docs/api/dynamic_schema.md
+        - Tests: tests/modules/test_setup_model.py
     """
 
     @classmethod
-    def get_clean_model(cls, *, config_fields: bool, hidden_fields: bool) -> type[SetupModelT]:  # type: ignore
-        """Dynamically builds and returns a new BaseModel subclass.
+    async def get_clean_model(
+        cls,
+        *,
+        config_fields: bool,
+        hidden_fields: bool,
+        force: bool = False,
+    ) -> type[SetupModelT]:
+        """Dynamically builds and returns a new BaseModel subclass with filtered fields.
 
-        containing only those fields where json_schema_extra["config"] == True.
+        This method filters fields based on their `json_schema_extra` metadata:
+        - Fields with `{"config": True}` are included only when `config_fields=True`
+        - Fields with `{"hidden": True}` are included only when `hidden_fields=True`
 
-        Returns:
-            Type[BaseModel]: A new BaseModel subclass with the filtered fields.
+        When `force=True`, fields with dynamic schema providers will have their
+        providers called to fetch fresh values for schema metadata like enums.
+        This includes recursively processing nested BaseModel fields.
 
-        Raises:
-            ValueError: If both config_fields and hidden_fields are set to True.
+        Args:
+            config_fields: If True, include fields marked with `{"config": True}`.
+                These are typically initial configuration fields.
+            hidden_fields: If True, include fields marked with `{"hidden": True}`.
+                These are typically runtime-only fields not shown in initial config.
+            force: If True, refresh dynamic schema fields by calling their providers.
+                Use this when you need up-to-date values from external sources like
+                databases or APIs. Default is False for performance.
+
+        Returns:
+            A new BaseModel subclass with filtered fields.
         """
         clean_fields: dict[str, Any] = {}
+
         for name, field_info in cls.model_fields.items():
             extra = getattr(field_info, "json_schema_extra", {}) or {}
             is_config = bool(extra.get("config", False))
@@ -93,7 +134,27 @@ class SetupModel(BaseModel):
                 logger.debug("Skipping '%s' (hidden-only)", name)
                 continue
 
-            clean_fields[name] = (field_info.annotation, field_info)
+            # Refresh dynamic schema fields when force=True
+            current_field_info = field_info
+            current_annotation = field_info.annotation
+
+            if force:
+                # Check if this field has DynamicField metadata
+                if has_dynamic(field_info):
+                    current_field_info = await cls._refresh_field_schema(name, field_info)
+
+                # Check if the annotation is a nested BaseModel that might have dynamic fields
+                nested_model = cls._get_base_model_type(current_annotation)
+                if nested_model is not None:
+                    refreshed_nested = await cls._refresh_nested_model(nested_model)
+                    if refreshed_nested is not nested_model:
+                        # Update annotation to use refreshed nested model
+                        current_annotation = refreshed_nested
+                        # Create new field_info with updated annotation (deep copy for safety)
+                        current_field_info = copy.deepcopy(current_field_info)
+                        setattr(current_field_info, "annotation", current_annotation)
+
+            clean_fields[name] = (current_annotation, current_field_info)
 
         # Dynamically create a model e.g. "SetupModel"
         m = create_model(
@@ -102,4 +163,231 @@ class SetupModel(BaseModel):
             __config__=ConfigDict(arbitrary_types_allowed=True),
             **clean_fields,
         )
-        return cast("type[SetupModelT]", m)  # type: ignore
+        return cast("type[SetupModelT]", m)
+
+    @classmethod
+    def _get_base_model_type(cls, annotation: type | None) -> type[BaseModel] | None:
+        """Extract BaseModel type from an annotation.
+
+        Handles direct types, Optional, Union, list, dict, set, tuple, and other generics.
+
+        Args:
+            annotation: The type annotation to inspect.
+
+        Returns:
+            The BaseModel subclass if found, None otherwise.
+        """
+        if annotation is None:
+            return None
+
+        # Direct BaseModel subclass check
+        if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+            return annotation
+
+        origin = get_origin(annotation)
+        if origin is None:
+            return None
+
+        args = get_args(annotation)
+        return cls._extract_base_model_from_args(origin, args)
+
+    @classmethod
+    def _extract_base_model_from_args(
+        cls,
+        origin: type,
+        args: tuple[type, ...],
+    ) -> type[BaseModel] | None:
+        """Extract BaseModel from generic type arguments.
+
+        Args:
+            origin: The generic origin type (list, dict, Union, etc.).
+            args: The type arguments.
+
+        Returns:
+            The BaseModel subclass if found, None otherwise.
+        """
+        # Union/Optional: check each arg (supports both typing.Union and types.UnionType)
+        # Python 3.10+ uses types.UnionType for X | Y syntax
+        if origin is typing.Union or origin is types.UnionType:
+            return cls._find_base_model_in_args(args)
+
+        # list, set, frozenset: check first arg
+        if origin in {list, set, frozenset} and args:
+            return cls._check_base_model(args[0])
+
+        # dict: check value type (second arg)
+        dict_value_index = 1
+        if origin is dict and len(args) > dict_value_index:
+            return cls._check_base_model(args[dict_value_index])
+
+        # tuple: check first non-ellipsis arg
+        if origin is tuple:
+            return cls._find_base_model_in_args(args, skip_ellipsis=True)
+
+        return None
+
+    @classmethod
+    def _check_base_model(cls, arg: type) -> type[BaseModel] | None:
+        """Check if arg is a BaseModel subclass.
+
+        Returns:
+            The BaseModel subclass if arg is one, None otherwise.
+        """
+        if isinstance(arg, type) and issubclass(arg, BaseModel):
+            return arg
+        return None
+
+    @classmethod
+    def _find_base_model_in_args(
+        cls,
+        args: tuple[type, ...],
+        *,
+        skip_ellipsis: bool = False,
+    ) -> type[BaseModel] | None:
+        """Find first BaseModel in args.
+
+        Returns:
+            The first BaseModel subclass found, None otherwise.
+        """
+        for arg in args:
+            if arg is type(None):
+                continue
+            if skip_ellipsis and arg is ...:
+                continue
+            result = cls._check_base_model(arg)
+            if result is not None:
+                return result
+        return None
+
+    @classmethod
+    async def _refresh_nested_model(cls, model_cls: type[BaseModel]) -> type[BaseModel]:
+        """Refresh dynamic fields in a nested BaseModel.
+
+        Creates a new model class with all DynamicField metadata resolved.
+
+        Args:
+            model_cls: The nested model class to refresh.
+
+        Returns:
+            A new model class with refreshed fields, or the original if no changes.
+        """
+        has_changes = False
+        clean_fields: dict[str, Any] = {}
+
+        for name, field_info in model_cls.model_fields.items():
+            current_field_info = field_info
+            current_annotation = field_info.annotation
+
+            # Check if field has DynamicField metadata
+            if has_dynamic(field_info):
+                current_field_info = await cls._refresh_field_schema(name, field_info)
+                has_changes = True
+
+            # Recursively check nested models
+            nested_model = cls._get_base_model_type(current_annotation)
+            if nested_model is not None:
+                refreshed_nested = await cls._refresh_nested_model(nested_model)
+                if refreshed_nested is not nested_model:
+                    current_annotation = refreshed_nested
+                    current_field_info = copy.deepcopy(current_field_info)
+                    setattr(current_field_info, "annotation", current_annotation)
+                    has_changes = True
+
+            clean_fields[name] = (current_annotation, current_field_info)
+
+        if not has_changes:
+            return model_cls
+
+        # Create new model with refreshed fields
+        logger.debug("Creating refreshed nested model for '%s'", model_cls.__name__)
+        return create_model(
+            model_cls.__name__,
+            __base__=BaseModel,
+            __config__=ConfigDict(arbitrary_types_allowed=True),
+            **clean_fields,
+        )
+
+    @classmethod
+    async def _refresh_field_schema(cls, field_name: str, field_info: FieldInfo) -> FieldInfo:
+        """Refresh a field's json_schema_extra with fresh values from dynamic providers.
+
+        This method calls all dynamic providers registered for a field (via Annotated
+        metadata) and creates a new FieldInfo with the resolved values. The original
+        field_info is not modified.
+
+        Uses `resolve_safe()` for structured error handling, allowing partial success
+        when some fetchers fail. Successfully resolved values are still applied.
+
+        Args:
+            field_name: The name of the field being refreshed (used for logging).
+            field_info: The original FieldInfo object containing the dynamic providers.
+
+        Returns:
+            A new FieldInfo object with the same attributes as the original, but with
+            `json_schema_extra` containing resolved values and Dynamic metadata removed.
+
+        Note:
+            If all fetchers fail, the original field_info is returned unchanged.
+            If some fetchers fail, successfully resolved values are still applied.
+        """
+        fetchers = get_fetchers(field_info)
+
+        if not fetchers:
+            return field_info
+
+        fetcher_keys = list(fetchers.keys())
+        logger.debug(
+            "Refreshing dynamic schema for field '%s' with fetchers: %s",
+            field_name,
+            fetcher_keys,
+            extra={"field_name": field_name, "fetcher_keys": fetcher_keys},
+        )
+
+        # Resolve all fetchers with structured error handling
+        result = await resolve_safe(fetchers)
+
+        # Log any errors that occurred with full details
+        if result.errors:
+            for key, error in result.errors.items():
+                logger.warning(
+                    "Failed to resolve '%s' for field '%s': %s: %s",
+                    key,
+                    field_name,
+                    type(error).__name__,
+                    str(error) or "(no message)",
+                    extra={
+                        "field_name": field_name,
+                        "fetcher_key": key,
+                        "error_type": type(error).__name__,
+                        "error_message": str(error),
+                        "error_repr": repr(error),
+                    },
+                )
+
+        # If no values were resolved, return original field_info
+        if not result.values:
+            logger.warning(
+                "All fetchers failed for field '%s', keeping original",
+                field_name,
+            )
+            return field_info
+
+        # Build new json_schema_extra with resolved values merged
+        extra = getattr(field_info, "json_schema_extra", {}) or {}
+        new_extra = {**extra, **result.values}
+
+        # Create a deep copy of the FieldInfo to avoid shared mutable state
+        new_field_info = copy.deepcopy(field_info)
+        setattr(new_field_info, "json_schema_extra", new_extra)
+
+        # Remove Dynamic from metadata (it's been resolved)
+        new_metadata = [m for m in new_field_info.metadata if not isinstance(m, DynamicField)]
+        setattr(new_field_info, "metadata", new_metadata)
+
+        logger.debug(
+            "Refreshed '%s' with dynamic values: %s",
+            field_name,
+            list(result.values.keys()),
+        )
+
+        return new_field_info