fleet-python 0.2.34__py3-none-any.whl → 0.2.36__py3-none-any.whl

fleet/__init__.py

@@ -46,8 +46,11 @@ from ._async.verifiers import (
     AsyncVerifierFunction,
 )
 
-# Import async tasks (default tasks are async for modern usage)
-from ._async.tasks import Task
+# Import async tasks (default tasks are async for modern usage)  
+from ._async.tasks import Task, load_tasks
+
+# Import sync load_tasks function
+from .tasks import load_tasks as load_tasks_sync
 
 # Import shared types
 from .types import VerifierFunction
@@ -94,19 +97,14 @@ __all__ = [
     "configure",
     "get_client",
     "reset_client",
+    # Module-level functions (async is default)
+    "load_tasks",
+    "load_tasks_sync",
     # Version
     "__version__",
 ]
 
 
-def load_tasks(env_key: Optional[str] = None) -> List[Task]:
-    """Load tasks without explicitly creating a client.
-
-    Example:
-        tasks = fleet.load_tasks(env_key="fira")
-    """
-    # Use global client by default so users can configure once
-    return _global_client.get_client().load_tasks(env_key=env_key)
 
 
 def configure(

fleet/_async/__init__.py

@@ -14,7 +14,7 @@
 
 """Fleet Python SDK - Async Environment-based AI agent interactions."""
 
-from typing import Optional, List
+from typing import Optional, List, Dict, Any
 
 from ..exceptions import (
     FleetError,
@@ -35,7 +35,7 @@ from .verifiers import (
 )
 
 # Import async tasks
-from .tasks import Task
+from .tasks import Task, load_tasks
 
 # Import shared types
 from ..types import VerifierFunction
@@ -93,33 +93,6 @@ __all__ = [
 ]
 
 
-async def load_tasks(
-    env_key: Optional[str] = None,
-    keys: Optional[List[str]] = None,
-    version: Optional[str] = None,
-    team_id: Optional[str] = None
-) -> List[Task]:
-    """Load tasks with optional filtering.
-
-    Args:
-        env_key: Optional environment key to filter tasks by
-        keys: Optional list of task keys to filter by
-        version: Optional version to filter tasks by
-
-    Examples:
-        tasks = await fleet.load_tasks(env_key="fira")
-        tasks = await fleet.load_tasks(keys=["task1", "task2"])
-        tasks = await fleet.load_tasks(env_key="fira", version="v1.0")
-    """
-    # Use global client by default so users can configure once
-    return await _async_global_client.get_client().load_tasks(
-        env_key=env_key, 
-        keys=keys, 
-        version=version, 
-        team_id=team_id
-    )
-
-
 async def list_envs() -> List[Environment]:
     """List all available environments."""
     return await _async_global_client.get_client().list_envs()
@@ -135,13 +108,14 @@ async def environment(env_key: str) -> Environment:
     return await _async_global_client.get_client().environment(env_key)
 
 
-async def make(env_key: str, region: Optional[str] = None) -> AsyncEnv:
+async def make(env_key: str, region: Optional[str] = None, env_variables: Optional[Dict[str, Any]] = None) -> AsyncEnv:
     """Create a new environment instance.
     
     Example:
         env = await fleet.make("fira")
+        env_with_vars = await fleet.make("fira", env_variables={"LOGGED_IN_NAME": "Alice"})
     """
-    return await _async_global_client.get_client().make(env_key, region)
+    return await _async_global_client.get_client().make(env_key, region, env_variables)
 
 
 async def make_for_task(task: Task) -> AsyncEnv:

fleet/_async/client.py

@@ -20,7 +20,7 @@ import httpx
 import json
 import logging
 import os
-from typing import List, Optional, Dict, TYPE_CHECKING
+from typing import List, Optional, Dict, Any, TYPE_CHECKING
 
 from .base import EnvironmentBase, AsyncWrapper
 from ..models import (
@@ -50,7 +50,7 @@ from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import AsyncSQLiteResource
 from .resources.browser import AsyncBrowserResource
-from ..resources.mcp import MCPResource
+from .resources.mcp import AsyncMCPResource
 
 logger = logging.getLogger(__name__)
 
@@ -105,9 +105,9 @@ class AsyncEnv(EnvironmentBase):
         return self.instance.browser(name)
 
     @property
-    def mcp(self) -> MCPResource:
+    def mcp(self) -> AsyncMCPResource:
         mcp_url = f"{self.urls.root}mcp"
-        return MCPResource(url=mcp_url, env_key=self.env_key)
+        return AsyncMCPResource(url=mcp_url, env_key=self.env_key)
 
     def state(self, uri: str) -> Resource:
         return self.instance.state(uri)
@@ -196,7 +196,7 @@ class AsyncFleet:
         response = await self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
 
-    async def make(self, env_key: str, region: Optional[str] = None) -> AsyncEnv:
+    async def make(self, env_key: str, region: Optional[str] = None, env_variables: Optional[Dict[str, Any]] = None) -> AsyncEnv:
         if ":" in env_key:
             env_key_part, version = env_key.split(":", 1)
             if (
@@ -210,7 +210,7 @@ class AsyncFleet:
             version = None
 
         request = InstanceRequest(
-            env_key=env_key_part, version=version, region=region, created_from="sdk"
+            env_key=env_key_part, version=version, region=region, env_variables=env_variables, created_from="sdk"
         )
         region_base_url = REGION_BASE_URL.get(region)
         response = await self.client.request(
@@ -507,12 +507,6 @@ class AsyncFleet:
             sha256=verifier_sha,
         )
         
-        # Ensure we return an AsyncVerifierFunction
-        if not isinstance(verifier_func, AsyncVerifierFunction):
-            raise TypeError(
-                f"Expected AsyncVerifierFunction but got {type(verifier_func).__name__}"
-            )
-        
         # Store the original verifier code for reference
         verifier_func._verifier_code = verifier_code
 

fleet/_async/env/client.py

@@ -1,10 +1,10 @@
 from ..client import AsyncFleet, AsyncEnv, Task
 from ...models import Environment as EnvironmentModel, AccountResponse
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
 
 
-async def make_async(env_key: str, region: Optional[str] = None) -> AsyncEnv:
-    return await AsyncFleet().make(env_key, region=region)
+async def make_async(env_key: str, region: Optional[str] = None, env_variables: Optional[Dict[str, Any]] = None) -> AsyncEnv:
+    return await AsyncFleet().make(env_key, region=region, env_variables=env_variables)
 
 
 async def make_for_task_async(task: Task) -> AsyncEnv:

fleet/_async/tasks.py

@@ -125,6 +125,56 @@ class Task(BaseModel):
         return await AsyncFleet().make(env_key=self.env_key, region=region)
 
 
+def verifier_from_string(
+    verifier_func: str,
+    verifier_id: str,
+    verifier_key: str,
+    sha256: str = ""
+) -> 'VerifierFunction':
+    """Create a verifier function from string code.
+    
+    Args:
+        verifier_func: The verifier function code as a string
+        verifier_id: Unique identifier for the verifier
+        verifier_key: Key/name for the verifier
+        sha256: SHA256 hash of the verifier code
+        
+    Returns:
+        VerifierFunction instance that can be used to verify tasks
+    """
+    try:
+        import inspect
+        from .verifiers import verifier, AsyncVerifierFunction
+        
+        # Create a local namespace for executing the code
+        local_namespace = {}
+        
+        # Execute the verifier code in the namespace
+        exec(verifier_func, globals(), local_namespace)
+        
+        # Find the function that was defined
+        func_obj = None
+        for name, obj in local_namespace.items():
+            if inspect.isfunction(obj):
+                func_obj = obj
+                break
+        
+        if func_obj is None:
+            raise ValueError("No function found in verifier code")
+        
+        # Create an AsyncVerifierFunction instance
+        verifier_instance = AsyncVerifierFunction(func_obj, verifier_key, verifier_id)
+        
+        # Store additional metadata
+        verifier_instance._verifier_code = verifier_func
+        verifier_instance._sha256 = sha256
+        
+        return verifier_instance
+        
+    except Exception as e:
+        raise ValueError(f"Failed to create verifier from string: {e}")
+
+
 async def load_tasks(
     env_key: Optional[str] = None,
     keys: Optional[List[str]] = None,

fleet/client.py

@@ -20,7 +20,7 @@ import httpx
 import json
 import logging
 import os
-from typing import List, Optional, Dict, TYPE_CHECKING
+from typing import List, Optional, Dict, Any, TYPE_CHECKING
 
 from .base import EnvironmentBase, SyncWrapper
 from .models import (
@@ -50,7 +50,7 @@ from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import SQLiteResource
 from .resources.browser import BrowserResource
-from ..resources.mcp import MCPResource
+from .resources.mcp import SyncMCPResource
 
 logger = logging.getLogger(__name__)
 
@@ -105,9 +105,9 @@ class SyncEnv(EnvironmentBase):
         return self.instance.browser(name)
 
     @property
-    def mcp(self) -> MCPResource:
+    def mcp(self) -> SyncMCPResource:
         mcp_url = f"{self.urls.root}mcp"
-        return MCPResource(url=mcp_url, env_key=self.env_key)
+        return SyncMCPResource(url=mcp_url, env_key=self.env_key)
 
     def state(self, uri: str) -> Resource:
         return self.instance.state(uri)
@@ -196,7 +196,7 @@ class Fleet:
         response = self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
 
-    def make(self, env_key: str, region: Optional[str] = None) -> SyncEnv:
+    def make(self, env_key: str, region: Optional[str] = None, env_variables: Optional[Dict[str, Any]] = None) -> SyncEnv:
         if ":" in env_key:
             env_key_part, version = env_key.split(":", 1)
             if (
@@ -210,7 +210,7 @@ class Fleet:
             version = None
 
         request = InstanceRequest(
-            env_key=env_key_part, version=version, region=region, created_from="sdk"
+            env_key=env_key_part, version=version, region=region, env_variables=env_variables, created_from="sdk"
         )
         region_base_url = REGION_BASE_URL.get(region)
         response = self.client.request(
@@ -496,14 +496,8 @@ class Fleet:
         Returns:
             AsyncVerifierFunction created from the verifier code
         """
-        from ..tasks import verifier_from_string
-        from .verifiers.verifier import SyncVerifierFunction
-
-        # Convert async verifier code to sync
-        if 'async def' in verifier_code:
-            verifier_code = verifier_code.replace('async def', 'def')
-        if 'await ' in verifier_code:
-            verifier_code = verifier_code.replace('await ', '')
+        from .tasks import verifier_from_string
+        from .verifiers import SyncVerifierFunction
         
         # Use verifier_from_string to create the verifier
         verifier_func = verifier_from_string(
@@ -513,12 +507,6 @@ class Fleet:
             sha256=verifier_sha,
         )
         
-        # Ensure we return an AsyncVerifierFunction
-        if not isinstance(verifier_func, SyncVerifierFunction):
-            raise TypeError(
-                f"Expected AsyncVerifierFunction but got {type(verifier_func).__name__}"
-            )
-        
         # Store the original verifier code for reference
         verifier_func._verifier_code = verifier_code
 

fleet/env/__init__.py

@@ -2,7 +2,7 @@
 
 from .client import (
     make,
-    make_for_task,
+    make_for_task_async,
     list_envs,
     list_regions,
     get,
@@ -22,7 +22,7 @@ from .._async.env.client import (
 
 __all__ = [
     "make",
-    "make_for_task",
+    "make_for_task_async",
     "list_envs",
     "list_regions",
     "list_instances",

fleet/env/client.py

@@ -1,10 +1,10 @@
 from ..client import Fleet, SyncEnv, Task
 from ..models import Environment as EnvironmentModel, AccountResponse
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
 
 
-def make(env_key: str, region: Optional[str] = None) -> SyncEnv:
-    return Fleet().make(env_key, region=region)
+def make(env_key: str, region: Optional[str] = None, env_variables: Optional[Dict[str, Any]] = None) -> SyncEnv:
+    return Fleet().make(env_key, region=region, env_variables=env_variables)
 
 
 def make_for_task_async(task: Task) -> SyncEnv:

fleet/global_client.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Optional
 
 from .client import Fleet
-from ..config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
+from .config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
 
 
 _default_client: Optional[Fleet] = None

fleet/tasks.py

@@ -124,6 +124,56 @@ class Task(BaseModel):
         return Fleet().make(env_key=self.env_key, region=region)
 
 
+def verifier_from_string(
+    verifier_func: str,
+    verifier_id: str,
+    verifier_key: str,
+    sha256: str = ""
+) -> 'VerifierFunction':
+    """Create a verifier function from string code.
+    
+    Args:
+        verifier_func: The verifier function code as a string
+        verifier_id: Unique identifier for the verifier
+        verifier_key: Key/name for the verifier
+        sha256: SHA256 hash of the verifier code
+        
+    Returns:
+        VerifierFunction instance that can be used to verify tasks
+    """
+    try:
+        import inspect
+        from .verifiers import verifier, SyncVerifierFunction
+        
+        # Create a local namespace for executing the code
+        local_namespace = {}
+        
+        # Execute the verifier code in the namespace
+        exec(verifier_func, globals(), local_namespace)
+        
+        # Find the function that was defined
+        func_obj = None
+        for name, obj in local_namespace.items():
+            if inspect.isfunction(obj):
+                func_obj = obj
+                break
+        
+        if func_obj is None:
+            raise ValueError("No function found in verifier code")
+        
+        # Create an AsyncVerifierFunction instance
+        verifier_instance = SyncVerifierFunction(func_obj, verifier_key, verifier_id)
+        
+        # Store additional metadata
+        verifier_instance._verifier_code = verifier_func
+        verifier_instance._sha256 = sha256
+        
+        return verifier_instance
+        
+    except Exception as e:
+        raise ValueError(f"Failed to create verifier from string: {e}")
+
+
 def load_tasks(
     env_key: Optional[str] = None,
     keys: Optional[List[str]] = None,

{fleet_python-0.2.34.dist-info → fleet_python-0.2.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.34
+Version: 0.2.36
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0

{fleet_python-0.2.34.dist-info → fleet_python-0.2.36.dist-info}/RECORD

@@ -19,24 +19,24 @@ examples/openai_simple_example.py,sha256=HmiufucrAZne7tHq9uoEsDWlEhjNC265bQAyIGB
 examples/query_builder_example.py,sha256=-cOMfWGNifYfYEt_Ds73XpwATZvFDL6F4KTkVxdMjzg,3951
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
-fleet/__init__.py,sha256=LYJ8zS6Ldo5wLpRqsFMoiikkyosTmm7sRTUY4SnJAgE,3880
+fleet/__init__.py,sha256=F6PrtihwOKZxmaOkeHmGLBM3feTpRTEDT5tSqeSD7ts,3749
 fleet/base.py,sha256=bc-340sTpq_DJs7yQ9d2pDWnmJFmA1SwDB9Lagvqtb4,9182
-fleet/client.py,sha256=JG9soTIkGK_uRezHU79PFn7PBXeN1iNpun1D4JDFTyE,22310
+fleet/client.py,sha256=nxYynq06wa7pWeMzPvwgAC6XBrb9rzujQfPi2hl_gmM,21876
 fleet/config.py,sha256=uY02ZKxVoXqVDta-0IMWaYJeE1CTXF_fA9NI6QUutmU,319
 fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
-fleet/global_client.py,sha256=oSWhV1cggVKQ0ec0YDOGu6Zr0Tgdcx3oKMM6s2Y9fQw,1073
+fleet/global_client.py,sha256=frrDAFNM2ywN0JHLtlm9qbE1dQpnQJsavJpb7xSR_bU,1072
 fleet/models.py,sha256=9tDjgcgKPMnf-R_MDh-Ocp_UMbyJ8tJyjb15XqU0N94,12454
-fleet/tasks.py,sha256=1AlNhe0WRggj3pIwTeaxMhpmMqI0MGBVjEmODVu37YI,5648
+fleet/tasks.py,sha256=vLFHHzgk7BBvDzGY1urEB_bzPaoV-kxNdRIFDttVqXo,7245
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
-fleet/_async/__init__.py,sha256=1X00u-0Zu4S-e8MGE9nJWbZEt3H-DHZA-gfwN-JuP2U,7415
+fleet/_async/__init__.py,sha256=lrnDD6N9p0Oqpi_djxTnxh8I5F7nA7KNn0khciGmgpg,6747
 fleet/_async/base.py,sha256=oisVTQsx0M_yTmyQJc3oij63uKZ97MHz-xYFsWXxQE8,9202
-fleet/_async/client.py,sha256=cX5eFE4J1nfdXddarc2HcNQpBYzQejlVWwbM2n3URlg,22497
+fleet/_async/client.py,sha256=WNaBwHJWRrOyYB79_qujdKkRMPmhpSucHbfTic9uc6A,22335
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
 fleet/_async/models.py,sha256=9tDjgcgKPMnf-R_MDh-Ocp_UMbyJ8tJyjb15XqU0N94,12454
-fleet/_async/tasks.py,sha256=jHGAvMkR3byayR429YSDiiIDV3W30y4UHZf9W6UhA8M,5721
+fleet/_async/tasks.py,sha256=hyBn2QWobcvG1k5snxxvYqohmpSv43iRghA-g6jx8Ro,7320
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/env/client.py,sha256=Fx4jVEGlM4JB_pgk9lZutzPAOgp6Yi3vxt3waMPrMvM,971
+fleet/_async/env/client.py,sha256=9GOSkEWNncwTtiZNaJ2vNGrFCPutyan9lBNhD87dAzQ,1059
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
 fleet/_async/instance/base.py,sha256=3qUBuUR8OVS36LzdP6KyZzngtwPKYO09HoY6Ekxp-KA,1625
 fleet/_async/instance/client.py,sha256=z9q_-dIBwPc1X6VlQOi_aV2v6KOKueJGg8NMyP5iFQM,6082
@@ -48,8 +48,8 @@ fleet/_async/resources/sqlite.py,sha256=h6pX41j8_aJaeZ7UVs25QQGgMWbHMPlGpDnPGMIA
 fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMTSOwxI,465
 fleet/_async/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
 fleet/_async/verifiers/verifier.py,sha256=lwVIV5ZpWJhM87tXShtjwN5KP7n5XDcPq0XX7AjV6_E,14343
-fleet/env/__init__.py,sha256=6-zgP705M61tCquiDKw29dBZGq1US9mtsB1gQngJ4FQ,664
-fleet/env/client.py,sha256=I4pjnXGzifZSr7iZFdn0cTX6nLuGYo-sCt-qk4ez29Y,805
+fleet/env/__init__.py,sha256=cS9zCYobM5jypppDMZIQMYd6hOg5f4sgqRXEQ67pckk,676
+fleet/env/client.py,sha256=wvZbmHdftkuhAgpzOGiA4Yl_Th9BUIHFR_6JUYg6Nc8,893
 fleet/instance/__init__.py,sha256=CyWUkbGAK-DBPw4DC4AnCW-MqqheGhZMA5QSRVu-ws4,479
 fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
 fleet/instance/client.py,sha256=O6B0A2Z0b5SxOLs4TipZ9Ol8yG-b-LG15vVOKMmd6BQ,5908
@@ -67,10 +67,10 @@ fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,
 fleet/verifiers/parse.py,sha256=0bAbj9VvT__yU4ZVREUK-Tn9dukh9LCpmfVsgj1DfP4,8508
 fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
 fleet/verifiers/verifier.py,sha256=53oBWAf0yy3bZmZx9eH9AWIf65H7OP2UUm0YwWCL6Mc,14286
-fleet_python-0.2.34.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-scripts/fix_sync_imports.py,sha256=0XKTkAV7WdMxRfk8-x4Ts1LjSbUpyI0tPL0DcTQ_38w,7308
+fleet_python-0.2.36.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scripts/fix_sync_imports.py,sha256=X9fWLTpiPGkSHsjyQUDepOJkxOqw1DPj7nd8wFlFqLQ,8368
 scripts/unasync.py,sha256=vWVQxRWX8SRZO5cmzEhpvnG_REhCWXpidIGIpWmEcvI,696
-fleet_python-0.2.34.dist-info/METADATA,sha256=WmolSCZR49qXHttFTyPhRnEJxj6po_YbDeUhOnk4t9M,3354
-fleet_python-0.2.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.34.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.34.dist-info/RECORD,,
+fleet_python-0.2.36.dist-info/METADATA,sha256=-MAGjnqjasQs79jubQHTQaWExDt6DsRPgLynJuDZzpM,3354
+fleet_python-0.2.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.36.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.36.dist-info/RECORD,,

scripts/fix_sync_imports.py

@@ -76,10 +76,25 @@ def fix_file(filepath: Path) -> bool:
         )
 
     # Fix imports in top-level fleet files
-    if rel_path.parts[0] in ["base.py", "client.py"] and len(rel_path.parts) == 1:
+    if rel_path.parts[0] in ["base.py", "client.py", "global_client.py"] and len(rel_path.parts) == 1:
         # Top-level files should use . for fleet level imports
         content = content.replace("from ..models import", "from .models import")
         content = content.replace("from ..config import", "from .config import")
+        content = content.replace("from ..tasks import", "from .tasks import")
+        
+        # Fix sync client error messages and imports
+        if rel_path.parts[0] == "client.py":
+            content = content.replace("Expected AsyncVerifierFunction but got", "Expected SyncVerifierFunction but got")
+            content = content.replace("# Ensure we return an AsyncVerifierFunction", "# Ensure we return a SyncVerifierFunction")
+            content = content.replace("from .verifiers.verifier import SyncVerifierFunction", "from .verifiers import SyncVerifierFunction")
+            
+            # Remove the type check entirely since it's causing import issues
+            content = re.sub(
+                r'\s*# Ensure we return a SyncVerifierFunction\s*\n\s*if not isinstance\(verifier_func, SyncVerifierFunction\):\s*\n\s*raise TypeError\(\s*f"Expected SyncVerifierFunction but got \{type\(verifier_func\)\.__name__\}"\s*\)\s*\n\s*',
+                '',
+                content,
+                flags=re.MULTILINE
+            )
 
     # Fix __init__.py imports - the class is called SyncEnv, not Environment
     if rel_path.parts[0] == "__init__.py" and len(rel_path.parts) == 1: