jaf-py 2.5.10__py3-none-any.whl → 2.5.11__py3-none-any.whl

jaf/a2a/memory/factory.py

@@ -27,16 +27,15 @@ from .types import (
 
 
 async def create_a2a_task_provider(
-    config: A2ATaskProviderConfig,
-    external_clients: Optional[Dict[str, Any]] = None
+    config: A2ATaskProviderConfig, external_clients: Optional[Dict[str, Any]] = None
 ) -> A2AResult[A2ATaskProvider]:
     """
     Create an A2A task provider from configuration
-    
+
     Args:
         config: Provider configuration
         external_clients: Optional external clients (redis, postgres)
-        
+
     Returns:
         A2AResult containing the task provider or an error
     """
@@ -44,32 +43,34 @@ async def create_a2a_task_provider(
         external_clients = external_clients or {}
 
         if config.type == "memory":
-            return create_a2a_success(
-                create_a2a_in_memory_task_provider(config)
-            )
+            return create_a2a_success(create_a2a_in_memory_task_provider(config))
 
         elif config.type == "redis":
-            redis_client = external_clients.get('redis')
+            redis_client = external_clients.get("redis")
             if not redis_client:
                 return create_a2a_failure(
                     create_a2a_task_storage_error(
-                        'create-provider',
-                        'redis',
+                        "create-provider",
+                        "redis",
                         None,
-                        Exception('Redis client instance required. Please provide a Redis client in external_clients.redis')
+                        Exception(
+                            "Redis client instance required. Please provide a Redis client in external_clients.redis"
+                        ),
                     )
                 )
             return await create_a2a_redis_task_provider(config, redis_client)
 
         elif config.type == "postgres":
-            postgres_client = external_clients.get('postgres')
+            postgres_client = external_clients.get("postgres")
             if not postgres_client:
                 return create_a2a_failure(
                     create_a2a_task_storage_error(
-                        'create-provider',
-                        'postgres',
+                        "create-provider",
+                        "postgres",
                         None,
-                        Exception('PostgreSQL client instance required. Please provide a PostgreSQL client in external_clients.postgres')
+                        Exception(
+                            "PostgreSQL client instance required. Please provide a PostgreSQL client in external_clients.postgres"
+                        ),
                     )
                 )
             return await create_a2a_postgres_task_provider(config, postgres_client)
@@ -77,287 +78,308 @@ async def create_a2a_task_provider(
         else:
             return create_a2a_failure(
                 create_a2a_task_storage_error(
-                    'create-provider',
-                    'unknown',
+                    "create-provider",
+                    "unknown",
                     None,
-                    Exception(f'Unknown A2A task provider type: {config.type}')
+                    Exception(f"Unknown A2A task provider type: {config.type}"),
                 )
             )
 
     except Exception as error:
         return create_a2a_failure(
-            create_a2a_task_storage_error('create-provider', 'factory', None, error)
+            create_a2a_task_storage_error("create-provider", "factory", None, error)
         )
 
+
 async def create_a2a_task_provider_from_env(
-    external_clients: Optional[Dict[str, Any]] = None
+    external_clients: Optional[Dict[str, Any]] = None,
 ) -> A2AResult[A2ATaskProvider]:
     """
     Create A2A task provider from environment variables
-    
+
     Args:
         external_clients: Optional external clients (redis, postgres)
-        
+
     Returns:
         A2AResult containing the task provider or an error
     """
     try:
         # Fall back to regular JAF memory type if A2A-specific one isn't set
-        task_memory_type = os.getenv('JAF_A2A_MEMORY_TYPE', os.getenv('JAF_MEMORY_TYPE', 'memory')).lower()
+        task_memory_type = os.getenv(
+            "JAF_A2A_MEMORY_TYPE", os.getenv("JAF_MEMORY_TYPE", "memory")
+        ).lower()
         external_clients = external_clients or {}
 
-        if task_memory_type == 'memory':
+        if task_memory_type == "memory":
             config = A2AInMemoryTaskConfig(
-                type='memory',
-                key_prefix=os.getenv('JAF_A2A_KEY_PREFIX', 'jaf:a2a:tasks:'),
-                default_ttl=int(os.getenv('JAF_A2A_DEFAULT_TTL')) if os.getenv('JAF_A2A_DEFAULT_TTL') else None,
-                cleanup_interval=int(os.getenv('JAF_A2A_CLEANUP_INTERVAL', '3600')),
-                max_tasks=int(os.getenv('JAF_A2A_MAX_TASKS', '10000')),
-                max_tasks_per_context=int(os.getenv('JAF_A2A_MAX_TASKS_PER_CONTEXT', '1000')),
-                enable_history=os.getenv('JAF_A2A_ENABLE_HISTORY', 'true').lower() != 'false',
-                enable_artifacts=os.getenv('JAF_A2A_ENABLE_ARTIFACTS', 'true').lower() != 'false'
+                type="memory",
+                key_prefix=os.getenv("JAF_A2A_KEY_PREFIX", "jaf:a2a:tasks:"),
+                default_ttl=int(os.getenv("JAF_A2A_DEFAULT_TTL"))
+                if os.getenv("JAF_A2A_DEFAULT_TTL")
+                else None,
+                cleanup_interval=int(os.getenv("JAF_A2A_CLEANUP_INTERVAL", "3600")),
+                max_tasks=int(os.getenv("JAF_A2A_MAX_TASKS", "10000")),
+                max_tasks_per_context=int(os.getenv("JAF_A2A_MAX_TASKS_PER_CONTEXT", "1000")),
+                enable_history=os.getenv("JAF_A2A_ENABLE_HISTORY", "true").lower() != "false",
+                enable_artifacts=os.getenv("JAF_A2A_ENABLE_ARTIFACTS", "true").lower() != "false",
             )
             return create_a2a_success(create_a2a_in_memory_task_provider(config))
 
-        elif task_memory_type == 'redis':
-            if not external_clients.get('redis'):
+        elif task_memory_type == "redis":
+            if not external_clients.get("redis"):
                 return create_a2a_failure(
                     create_a2a_task_storage_error(
-                        'create-provider-from-env',
-                        'redis',
+                        "create-provider-from-env",
+                        "redis",
                         None,
-                        Exception('Redis client required for Redis A2A task provider')
+                        Exception("Redis client required for Redis A2A task provider"),
                     )
                 )
 
             config = A2ARedisTaskConfig(
-                type='redis',
-                key_prefix=os.getenv('JAF_A2A_KEY_PREFIX', 'jaf:a2a:tasks:'),
-                default_ttl=int(os.getenv('JAF_A2A_DEFAULT_TTL', os.getenv('JAF_REDIS_TTL'))) if os.getenv('JAF_A2A_DEFAULT_TTL', os.getenv('JAF_REDIS_TTL')) else None,
-                cleanup_interval=int(os.getenv('JAF_A2A_CLEANUP_INTERVAL', '3600')),
-                max_tasks=int(os.getenv('JAF_A2A_MAX_TASKS', '10000')),
-                enable_history=os.getenv('JAF_A2A_ENABLE_HISTORY', 'true').lower() != 'false',
-                enable_artifacts=os.getenv('JAF_A2A_ENABLE_ARTIFACTS', 'true').lower() != 'false',
-                host=os.getenv('JAF_A2A_REDIS_HOST', os.getenv('JAF_REDIS_HOST', 'localhost')),
-                port=int(os.getenv('JAF_A2A_REDIS_PORT', os.getenv('JAF_REDIS_PORT', '6379'))),
-                password=os.getenv('JAF_A2A_REDIS_PASSWORD', os.getenv('JAF_REDIS_PASSWORD')),
-                db=int(os.getenv('JAF_A2A_REDIS_DB', os.getenv('JAF_REDIS_DB', '0')))
+                type="redis",
+                key_prefix=os.getenv("JAF_A2A_KEY_PREFIX", "jaf:a2a:tasks:"),
+                default_ttl=int(os.getenv("JAF_A2A_DEFAULT_TTL", os.getenv("JAF_REDIS_TTL")))
+                if os.getenv("JAF_A2A_DEFAULT_TTL", os.getenv("JAF_REDIS_TTL"))
+                else None,
+                cleanup_interval=int(os.getenv("JAF_A2A_CLEANUP_INTERVAL", "3600")),
+                max_tasks=int(os.getenv("JAF_A2A_MAX_TASKS", "10000")),
+                enable_history=os.getenv("JAF_A2A_ENABLE_HISTORY", "true").lower() != "false",
+                enable_artifacts=os.getenv("JAF_A2A_ENABLE_ARTIFACTS", "true").lower() != "false",
+                host=os.getenv("JAF_A2A_REDIS_HOST", os.getenv("JAF_REDIS_HOST", "localhost")),
+                port=int(os.getenv("JAF_A2A_REDIS_PORT", os.getenv("JAF_REDIS_PORT", "6379"))),
+                password=os.getenv("JAF_A2A_REDIS_PASSWORD", os.getenv("JAF_REDIS_PASSWORD")),
+                db=int(os.getenv("JAF_A2A_REDIS_DB", os.getenv("JAF_REDIS_DB", "0"))),
             )
-            return await create_a2a_redis_task_provider(config, external_clients['redis'])
+            return await create_a2a_redis_task_provider(config, external_clients["redis"])
 
-        elif task_memory_type == 'postgres':
-            if not external_clients.get('postgres'):
+        elif task_memory_type == "postgres":
+            if not external_clients.get("postgres"):
                 return create_a2a_failure(
                     create_a2a_task_storage_error(
-                        'create-provider-from-env',
-                        'postgres',
+                        "create-provider-from-env",
+                        "postgres",
                         None,
-                        Exception('PostgreSQL client required for PostgreSQL A2A task provider')
+                        Exception("PostgreSQL client required for PostgreSQL A2A task provider"),
                     )
                 )
 
             config = A2APostgresTaskConfig(
-                type='postgres',
-                key_prefix=os.getenv('JAF_A2A_KEY_PREFIX', 'jaf:a2a:tasks:'),
-                default_ttl=int(os.getenv('JAF_A2A_DEFAULT_TTL')) if os.getenv('JAF_A2A_DEFAULT_TTL') else None,
-                cleanup_interval=int(os.getenv('JAF_A2A_CLEANUP_INTERVAL', '3600')),
-                max_tasks=int(os.getenv('JAF_A2A_MAX_TASKS', '10000')),
-                enable_history=os.getenv('JAF_A2A_ENABLE_HISTORY', 'true').lower() != 'false',
-                enable_artifacts=os.getenv('JAF_A2A_ENABLE_ARTIFACTS', 'true').lower() != 'false',
-                host=os.getenv('JAF_A2A_POSTGRES_HOST', os.getenv('JAF_POSTGRES_HOST', 'localhost')),
-                port=int(os.getenv('JAF_A2A_POSTGRES_PORT', os.getenv('JAF_POSTGRES_PORT', '5432'))),
-                database=os.getenv('JAF_A2A_POSTGRES_DB', os.getenv('JAF_POSTGRES_DB', 'jaf_a2a')),
-                username=os.getenv('JAF_A2A_POSTGRES_USER', os.getenv('JAF_POSTGRES_USER', 'postgres')),
-                password=os.getenv('JAF_A2A_POSTGRES_PASSWORD', os.getenv('JAF_POSTGRES_PASSWORD')),
-                ssl=os.getenv('JAF_A2A_POSTGRES_SSL', os.getenv('JAF_POSTGRES_SSL', 'false')).lower() == 'true',
-                table_name=os.getenv('JAF_A2A_POSTGRES_TABLE', 'a2a_tasks'),
-                max_connections=int(os.getenv('JAF_A2A_POSTGRES_MAX_CONNECTIONS', os.getenv('JAF_POSTGRES_MAX_CONNECTIONS', '10')))
+                type="postgres",
+                key_prefix=os.getenv("JAF_A2A_KEY_PREFIX", "jaf:a2a:tasks:"),
+                default_ttl=int(os.getenv("JAF_A2A_DEFAULT_TTL"))
+                if os.getenv("JAF_A2A_DEFAULT_TTL")
+                else None,
+                cleanup_interval=int(os.getenv("JAF_A2A_CLEANUP_INTERVAL", "3600")),
+                max_tasks=int(os.getenv("JAF_A2A_MAX_TASKS", "10000")),
+                enable_history=os.getenv("JAF_A2A_ENABLE_HISTORY", "true").lower() != "false",
+                enable_artifacts=os.getenv("JAF_A2A_ENABLE_ARTIFACTS", "true").lower() != "false",
+                host=os.getenv(
+                    "JAF_A2A_POSTGRES_HOST", os.getenv("JAF_POSTGRES_HOST", "localhost")
+                ),
+                port=int(
+                    os.getenv("JAF_A2A_POSTGRES_PORT", os.getenv("JAF_POSTGRES_PORT", "5432"))
+                ),
+                database=os.getenv("JAF_A2A_POSTGRES_DB", os.getenv("JAF_POSTGRES_DB", "jaf_a2a")),
+                username=os.getenv(
+                    "JAF_A2A_POSTGRES_USER", os.getenv("JAF_POSTGRES_USER", "postgres")
+                ),
+                password=os.getenv("JAF_A2A_POSTGRES_PASSWORD", os.getenv("JAF_POSTGRES_PASSWORD")),
+                ssl=os.getenv(
+                    "JAF_A2A_POSTGRES_SSL", os.getenv("JAF_POSTGRES_SSL", "false")
+                ).lower()
+                == "true",
+                table_name=os.getenv("JAF_A2A_POSTGRES_TABLE", "a2a_tasks"),
+                max_connections=int(
+                    os.getenv(
+                        "JAF_A2A_POSTGRES_MAX_CONNECTIONS",
+                        os.getenv("JAF_POSTGRES_MAX_CONNECTIONS", "10"),
+                    )
+                ),
             )
-            return await create_a2a_postgres_task_provider(config, external_clients['postgres'])
+            return await create_a2a_postgres_task_provider(config, external_clients["postgres"])
 
         else:
             return create_a2a_failure(
                 create_a2a_task_storage_error(
-                    'create-provider-from-env',
-                    'unknown',
+                    "create-provider-from-env",
+                    "unknown",
                     None,
-                    Exception(f'Unknown A2A task provider type: {task_memory_type}')
+                    Exception(f"Unknown A2A task provider type: {task_memory_type}"),
                 )
             )
 
     except Exception as error:
         return create_a2a_failure(
-            create_a2a_task_storage_error('create-provider-from-env', 'factory', None, error)
+            create_a2a_task_storage_error("create-provider-from-env", "factory", None, error)
         )
 
+
 async def create_simple_a2a_task_provider(
-    provider_type: str,
-    client: Optional[Any] = None,
-    config: Optional[Dict[str, Any]] = None
+    provider_type: str, client: Optional[Any] = None, config: Optional[Dict[str, Any]] = None
 ) -> A2AResult[A2ATaskProvider]:
     """
     Helper function to create A2A task provider with sensible defaults
-    
+
     Args:
         provider_type: Type of provider ('memory', 'redis', 'postgres')
         client: External client for redis/postgres providers
         config: Optional configuration overrides
-        
+
     Returns:
         A2AResult containing the task provider or an error
     """
     try:
         config = config or {}
 
-        if provider_type == 'memory':
+        if provider_type == "memory":
             provider_config = A2AInMemoryTaskConfig(
-                type='memory',
-                key_prefix='jaf:a2a:tasks:',
+                type="memory",
+                key_prefix="jaf:a2a:tasks:",
                 default_ttl=None,
                 cleanup_interval=3600,
                 max_tasks=10000,
                 max_tasks_per_context=1000,
                 enable_history=True,
                 enable_artifacts=True,
-                **config
+                **config,
             )
             return create_a2a_success(create_a2a_in_memory_task_provider(provider_config))
 
-        elif provider_type == 'redis':
+        elif provider_type == "redis":
             if not client:
                 return create_a2a_failure(
                     create_a2a_task_storage_error(
-                        'create-simple-provider',
-                        'redis',
+                        "create-simple-provider",
+                        "redis",
                         None,
-                        Exception('Redis client required for Redis A2A task provider')
+                        Exception("Redis client required for Redis A2A task provider"),
                     )
                 )
 
             provider_config = A2ARedisTaskConfig(
-                type='redis',
-                key_prefix='jaf:a2a:tasks:',
+                type="redis",
+                key_prefix="jaf:a2a:tasks:",
                 default_ttl=None,
                 cleanup_interval=3600,
                 max_tasks=10000,
                 enable_history=True,
                 enable_artifacts=True,
-                host='localhost',
+                host="localhost",
                 port=6379,
                 password=None,
                 db=0,
-                **config
+                **config,
             )
             return await create_a2a_redis_task_provider(provider_config, client)
 
-        elif provider_type == 'postgres':
+        elif provider_type == "postgres":
             if not client:
                 return create_a2a_failure(
                     create_a2a_task_storage_error(
-                        'create-simple-provider',
-                        'postgres',
+                        "create-simple-provider",
+                        "postgres",
                         None,
-                        Exception('PostgreSQL client required for PostgreSQL A2A task provider')
+                        Exception("PostgreSQL client required for PostgreSQL A2A task provider"),
                     )
                 )
 
             provider_config = A2APostgresTaskConfig(
-                type='postgres',
-                key_prefix='jaf:a2a:tasks:',
+                type="postgres",
+                key_prefix="jaf:a2a:tasks:",
                 default_ttl=None,
                 cleanup_interval=3600,
                 max_tasks=10000,
                 enable_history=True,
                 enable_artifacts=True,
-                host='localhost',
+                host="localhost",
                 port=5432,
-                database='jaf_a2a',
-                username='postgres',
+                database="jaf_a2a",
+                username="postgres",
                 password=None,
                 ssl=False,
-                table_name='a2a_tasks',
+                table_name="a2a_tasks",
                 max_connections=10,
-                **config
+                **config,
             )
             return await create_a2a_postgres_task_provider(provider_config, client)
 
         else:
             return create_a2a_failure(
                 create_a2a_task_storage_error(
-                    'create-simple-provider',
-                    'unknown',
+                    "create-simple-provider",
+                    "unknown",
                     None,
-                    Exception(f'Unknown A2A task provider type: {provider_type}')
+                    Exception(f"Unknown A2A task provider type: {provider_type}"),
                 )
             )
 
     except Exception as error:
         return create_a2a_failure(
-            create_a2a_task_storage_error('create-simple-provider', 'factory', None, error)
+            create_a2a_task_storage_error("create-simple-provider", "factory", None, error)
         )
 
+
 def create_composite_a2a_task_provider(
-    primary: A2ATaskProvider,
-    fallback: Optional[A2ATaskProvider] = None
+    primary: A2ATaskProvider, fallback: Optional[A2ATaskProvider] = None
 ) -> A2ATaskProvider:
     """
     Create a composite A2A task provider that can use multiple backends
     Useful for implementing failover or read/write splitting
-    
+
     Args:
         primary: Primary task provider
         fallback: Optional fallback provider
-        
+
     Returns:
         Composite A2ATaskProvider
     """
     from .providers.composite import create_composite_a2a_task_provider as create_composite
+
     return create_composite(primary, fallback)
 
+
 def validate_a2a_task_provider_config(config: A2ATaskProviderConfig) -> Dict[str, Any]:
     """
     Pure function to validate A2A task provider configuration
-    
+
     Args:
         config: Configuration to validate
-        
+
     Returns:
         Dictionary with 'valid' boolean and 'errors' list
     """
     errors = []
 
     if not config.type:
-        errors.append('Provider type is required')
-    elif config.type not in ['memory', 'redis', 'postgres']:
-        errors.append(f'Invalid provider type: {config.type}')
+        errors.append("Provider type is required")
+    elif config.type not in ["memory", "redis", "postgres"]:
+        errors.append(f"Invalid provider type: {config.type}")
 
     if config.max_tasks and config.max_tasks <= 0:
-        errors.append('max_tasks must be greater than 0')
+        errors.append("max_tasks must be greater than 0")
 
     if config.cleanup_interval and config.cleanup_interval <= 0:
-        errors.append('cleanup_interval must be greater than 0')
+        errors.append("cleanup_interval must be greater than 0")
 
     if config.default_ttl and config.default_ttl <= 0:
-        errors.append('default_ttl must be greater than 0')
+        errors.append("default_ttl must be greater than 0")
 
     # Type-specific validation
-    if config.type == 'memory':
-        if hasattr(config, 'max_tasks_per_context') and config.max_tasks_per_context <= 0:
-            errors.append('max_tasks_per_context must be greater than 0')
+    if config.type == "memory":
+        if hasattr(config, "max_tasks_per_context") and config.max_tasks_per_context <= 0:
+            errors.append("max_tasks_per_context must be greater than 0")
 
-    elif config.type == 'redis':
+    elif config.type == "redis":
         if config.port and (config.port < 1 or config.port > 65535):
-            errors.append('Redis port must be between 1 and 65535')
+            errors.append("Redis port must be between 1 and 65535")
         if config.db and config.db < 0:
-            errors.append('Redis database index must be non-negative')
+            errors.append("Redis database index must be non-negative")
 
-    elif config.type == 'postgres':
+    elif config.type == "postgres":
         if config.port and (config.port < 1 or config.port > 65535):
-            errors.append('PostgreSQL port must be between 1 and 65535')
-        if hasattr(config, 'max_connections') and config.max_connections <= 0:
-            errors.append('max_connections must be greater than 0')
-
-    return {
-        'valid': len(errors) == 0,
-        'errors': errors
-    }
+            errors.append("PostgreSQL port must be between 1 and 65535")
+        if hasattr(config, "max_connections") and config.max_connections <= 0:
+            errors.append("max_connections must be greater than 0")
+
+    return {"valid": len(errors) == 0, "errors": errors}

jaf/a2a/memory/providers/composite.py

@@ -21,16 +21,15 @@ from ..types import (
 
 
 def create_composite_a2a_task_provider(
-    primary: A2ATaskProvider,
-    fallback: Optional[A2ATaskProvider] = None
+    primary: A2ATaskProvider, fallback: Optional[A2ATaskProvider] = None
 ) -> A2ATaskProvider:
     """
     Create a composite A2A task provider that can use multiple backends
-    
+
     Args:
         primary: Primary task provider
         fallback: Optional fallback provider for failover
-        
+
     Returns:
         Composite A2ATaskProvider
     """
@@ -39,9 +38,7 @@ def create_composite_a2a_task_provider(
         """Composite implementation of A2ATaskProvider"""
 
         async def store_task(
-            self,
-            task: A2ATask,
-            metadata: Optional[Dict[str, Any]] = None
+            self, task: A2ATask, metadata: Optional[Dict[str, Any]] = None
         ) -> A2AResult[None]:
             """Store task in primary, fallback to secondary if primary fails"""
             result = await primary.store_task(task, metadata)
@@ -57,9 +54,7 @@ def create_composite_a2a_task_provider(
             return result
 
         async def update_task(
-            self,
-            task: A2ATask,
-            metadata: Optional[Dict[str, Any]] = None
+            self, task: A2ATask, metadata: Optional[Dict[str, Any]] = None
         ) -> A2AResult[None]:
             """Update task in primary, fallback to secondary if primary fails"""
             result = await primary.update_task(task, metadata)
@@ -72,7 +67,7 @@ def create_composite_a2a_task_provider(
             task_id: str,
             state: TaskState,
             status_message: Optional[Any] = None,
-            timestamp: Optional[str] = None
+            timestamp: Optional[str] = None,
         ) -> A2AResult[None]:
             """Update task status in primary, fallback to secondary if primary fails"""
             result = await primary.update_task_status(task_id, state, status_message, timestamp)
@@ -88,9 +83,7 @@ def create_composite_a2a_task_provider(
             return result
 
         async def get_tasks_by_context(
-            self,
-            context_id: str,
-            limit: Optional[int] = None
+            self, context_id: str, limit: Optional[int] = None
         ) -> A2AResult[List[A2ATask]]:
             """Get tasks by context from primary, fallback to secondary if primary fails"""
             result = await primary.get_tasks_by_context(context_id, limit)
@@ -144,8 +137,7 @@ def create_composite_a2a_task_provider(
             return primary_result
 
         async def get_task_stats(
-            self,
-            context_id: Optional[str] = None
+            self, context_id: Optional[str] = None
         ) -> A2AResult[Dict[str, Any]]:
             """Get task stats from primary, fallback to secondary if primary fails"""
             result = await primary.get_task_stats(context_id)
@@ -162,21 +154,24 @@ def create_composite_a2a_task_provider(
                 fallback_health = await fallback.health_check()
 
             # Determine overall health
-            primary_healthy = (
-                isinstance(primary_health.data, dict) and
-                primary_health.data.get('healthy', False)
+            primary_healthy = isinstance(primary_health.data, dict) and primary_health.data.get(
+                "healthy", False
             )
-            fallback_healthy = (
-                fallback_health is None or
-                (isinstance(fallback_health.data, dict) and fallback_health.data.get('healthy', False))
+            fallback_healthy = fallback_health is None or (
+                isinstance(fallback_health.data, dict)
+                and fallback_health.data.get("healthy", False)
             )
 
             overall_healthy = primary_healthy or fallback_healthy
 
             health_data = {
-                'healthy': overall_healthy,
-                'primary': primary_health.data if isinstance(primary_health.data, dict) else {'healthy': False},
-                'fallback': fallback_health.data if fallback_health and isinstance(fallback_health.data, dict) else None
+                "healthy": overall_healthy,
+                "primary": primary_health.data
+                if isinstance(primary_health.data, dict)
+                else {"healthy": False},
+                "fallback": fallback_health.data
+                if fallback_health and isinstance(fallback_health.data, dict)
+                else None,
             }
 
             return create_a2a_success(health_data)
@@ -195,7 +190,7 @@ def create_composite_a2a_task_provider(
 
             except Exception as error:
                 return create_a2a_failure(
-                    create_a2a_task_storage_error('close', 'composite', None, error)
+                    create_a2a_task_storage_error("close", "composite", None, error)
                 )
 
     return CompositeA2ATaskProvider()