fleet-python 0.2.66b4__tar.gz → 0.2.68__tar.gz

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/PKG-INFO

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

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/examples/export_tasks.py

@@ -27,6 +27,12 @@ def main():
         help="Optional task project key to filter tasks",
         default=None,
     )
+    parser.add_argument(
+        "--env-key",
+        "-e",
+        help="Optional environment key to filter tasks",
+        default=None,
+    )
     parser.add_argument(
         "--output",
         "-o",
@@ -42,12 +48,13 @@ def main():
             args.project_key is not None,
             args.task_keys is not None,
             args.task_project_key is not None,
+            args.env_key is not None,
         ]
     )
 
     if filters_specified > 1:
         parser.error(
-            "Cannot specify multiple filters. Use only one of --project-key, --task-keys, or --task-project-key."
+            "Cannot specify multiple filters. Use only one of --project-key, --task-keys, --task-project-key, or --env-key."
         )
 
     # Get account info
@@ -66,6 +73,9 @@ def main():
     elif args.task_project_key:
         print(f"Loading tasks from task project: {args.task_project_key}")
         tasks = fleet.load_tasks(task_project_key=args.task_project_key)
+    elif args.env_key:
+        print(f"Loading tasks from environment: {args.env_key}")
+        tasks = fleet.load_tasks(env_key=args.env_key)
     else:
         print("Loading all tasks")
         tasks = fleet.load_tasks()

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/examples/import_tasks.py

@@ -210,9 +210,18 @@ async def main():
         action="store_true",
         help="Skip the verifier sanity check (not recommended)",
     )
+    parser.add_argument(
+        "--sanity-check-only",
+        action="store_true",
+        help="Only run the sanity check without importing tasks",
+    )
 
     args = parser.parse_args()
 
+    # Validate conflicting flags
+    if args.skip_sanity_check and args.sanity_check_only:
+        parser.error("Cannot use --skip-sanity-check and --sanity-check-only together")
+
     # Load and parse the JSON file
     try:
         with open(args.json_file, "r", encoding="utf-8") as f:
@@ -286,6 +295,12 @@ async def main():
         success, errors = await run_verifier_sanity_check(tasks, client)
         if not success:
             sys.exit(1)
+
+        # If only doing sanity check, exit successfully here
+        if args.sanity_check_only:
+            print("\n✓ Sanity check complete! (--sanity-check-only)")
+            print("Tasks are ready to import.")
+            sys.exit(0)
     else:
         print("\n⚠️  Skipping sanity check (--skip-sanity-check)")
 

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/fleet/_async/client.py

@@ -212,6 +212,7 @@ class AsyncFleet:
         env_variables: Optional[Dict[str, Any]] = None,
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
+        run_id: Optional[str] = None,
     ) -> AsyncEnv:
         if ":" in env_key:
             env_key_part, env_version = env_key.split(":", 1)
@@ -247,6 +248,7 @@ class AsyncFleet:
             image_type=image_type,
             created_from="sdk",
             ttl_seconds=ttl_seconds,
+            run_id=run_id,
         )
 
         # Only use region-specific base URL if no custom base URL is set
@@ -269,13 +271,15 @@ class AsyncFleet:
         return await self.make(env_key=f"{task.env_id}:{task.version}")
 
     async def instances(
-        self, status: Optional[str] = None, region: Optional[str] = None
+        self, status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None
     ) -> List[AsyncEnv]:
         params = {}
         if status:
             params["status"] = status
         if region:
             params["region"] = region
+        if run_id:
+            params["run_id"] = run_id
 
         response = await self.client.request("GET", "/v1/env/instances", params=params)
         return [
@@ -302,6 +306,28 @@ class AsyncFleet:
     async def delete(self, instance_id: str) -> InstanceResponse:
         return await _delete_instance(self.client, instance_id)
 
+    async def close(self, instance_id: str) -> InstanceResponse:
+        """Close (delete) a specific instance by ID.
+        
+        Args:
+            instance_id: The instance ID to close
+            
+        Returns:
+            InstanceResponse containing the deleted instance details
+        """
+        return await _delete_instance(self.client, instance_id)
+
+    async def close_all(self, run_id: str) -> List[InstanceResponse]:
+        """Close (delete) all instances associated with a run_id.
+        
+        Args:
+            run_id: The run ID whose instances should be closed
+            
+        Returns:
+            List[InstanceResponse] containing the deleted instances
+        """
+        return await _delete_instances_by_run_id(self.client, run_id)
+
     async def load_tasks_from_file(self, filename: str) -> List[Task]:
         with open(filename, "r", encoding="utf-8") as f:
             tasks_data = f.read()
@@ -553,7 +579,7 @@ class AsyncFleet:
                 env_variables=task_response.env_variables or {},
                 verifier_func=verifier_func,  # Set verifier code
                 verifier=verifier,  # Use created verifier or None
-                metadata={},  # Default empty metadata
+                metadata=task_response.metadata or {},
                 output_json_schema=getattr(task_response, "output_json_schema", None),  # Get output_json_schema if available
             )
             tasks.append(task)
@@ -708,6 +734,7 @@ class AsyncFleet:
         task_key: str,
         prompt: Optional[str] = None,
         verifier_code: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> TaskResponse:
         """Update an existing task.
 
@@ -715,11 +742,12 @@ class AsyncFleet:
             task_key: The key of the task to update
             prompt: New prompt text for the task (optional)
             verifier_code: Python code for task verification (optional)
+            metadata: Additional metadata for the task (optional)
 
         Returns:
             TaskResponse containing the updated task details
         """
-        payload = TaskUpdateRequest(prompt=prompt, verifier_code=verifier_code)
+        payload = TaskUpdateRequest(prompt=prompt, verifier_code=verifier_code, metadata=metadata)
         response = await self.client.request(
             "PUT", f"/v1/tasks/{task_key}", json=payload.model_dump(exclude_none=True)
         )
@@ -809,6 +837,11 @@ async def _delete_instance(client: AsyncWrapper, instance_id: str) -> InstanceRe
     return InstanceResponse(**response.json())
 
 
+async def _delete_instances_by_run_id(client: AsyncWrapper, run_id: str) -> List[InstanceResponse]:
+    response = await client.request("DELETE", f"/v1/env/instances/run/{run_id}")
+    return [InstanceResponse(**instance_data) for instance_data in response.json()]
+
+
 async def _check_bundle_exists(
     client: AsyncWrapper, bundle_hash: str
 ) -> VerifiersCheckResponse:

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/fleet/_async/env/client.py

@@ -1,5 +1,5 @@
 from ..client import AsyncFleet, AsyncEnv, Task
-from ...models import Environment as EnvironmentModel, AccountResponse
+from ...models import Environment as EnvironmentModel, AccountResponse, InstanceResponse
 from typing import List, Optional, Dict, Any
 
 
@@ -10,6 +10,7 @@ async def make_async(
     env_variables: Optional[Dict[str, Any]] = None,
     image_type: Optional[str] = None,
     ttl_seconds: Optional[int] = None,
+    run_id: Optional[str] = None,
 ) -> AsyncEnv:
     return await AsyncFleet().make(
         env_key,
@@ -18,6 +19,7 @@ async def make_async(
         env_variables=env_variables,
         image_type=image_type,
         ttl_seconds=ttl_seconds,
+        run_id=run_id,
     )
 
 
@@ -34,14 +36,38 @@ async def list_regions_async() -> List[str]:
 
 
 async def list_instances_async(
-    status: Optional[str] = None, region: Optional[str] = None
+    status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None
 ) -> List[AsyncEnv]:
-    return await AsyncFleet().instances(status=status, region=region)
+    return await AsyncFleet().instances(status=status, region=region, run_id=run_id)
 
 
 async def get_async(instance_id: str) -> AsyncEnv:
     return await AsyncFleet().instance(instance_id)
 
 
+async def close_async(instance_id: str) -> InstanceResponse:
+    """Close (delete) a specific instance by ID.
+    
+    Args:
+        instance_id: The instance ID to close
+        
+    Returns:
+        InstanceResponse containing the deleted instance details
+    """
+    return await AsyncFleet().close(instance_id)
+
+
+async def close_all_async(run_id: str) -> List[InstanceResponse]:
+    """Close (delete) all instances associated with a run_id.
+    
+    Args:
+        run_id: The run ID whose instances should be closed
+        
+    Returns:
+        List[InstanceResponse] containing the deleted instances
+    """
+    return await AsyncFleet().close_all(run_id)
+
+
 async def account_async() -> AccountResponse:
     return await AsyncFleet().account()

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/fleet/_async/models.py

@@ -155,12 +155,14 @@ class TaskRequest(BaseModel):
     verifier_id: Optional[str] = Field(None, title="Verifier Id")
     version: Optional[str] = Field(None, title="Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
+    metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
     output_json_schema: Optional[Dict[str, Any]] = Field(None, title="Output Json Schema")
 
 
 class TaskUpdateRequest(BaseModel):
     prompt: Optional[str] = Field(None, title="Prompt")
     verifier_code: Optional[str] = Field(None, title="Verifier Code")
+    metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
 
 
 class VerifierData(BaseModel):
@@ -186,6 +188,7 @@ class TaskResponse(BaseModel):
     data_version: Optional[str] = Field(None, title="Data Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
     verifier: Optional[VerifierData] = Field(None, title="Verifier")
+    metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
     output_json_schema: Optional[Dict[str, Any]] = Field(None, title="Output Json Schema")
 
 

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/fleet/_async/tasks.py

@@ -209,23 +209,27 @@ class Task(BaseModel):
             )
             self.verifier = verifier
 
-    async def make_env(self, region: Optional[str] = None):
+    async def make_env(
+        self,
+        region: Optional[str] = None,
+        image_type: Optional[str] = None,
+        ttl_seconds: Optional[int] = None,
+        run_id: Optional[str] = None,
+    ):
         """Create an environment instance for this task's environment.
 
-        Uses the task's env_id (and version if present) to create the env.
+        Alias for make() method. Uses the task's env_id (and version if present) to create the env.
         """
-        if not self.env_id:
-            raise ValueError("Task has no env_id defined")
-        # Deferred import to avoid circular dependencies
-        from .client import AsyncFleet
-
-        return await AsyncFleet().make(env_key=self.env_key, region=region)
+        return await self.make(
+            region=region, image_type=image_type, ttl_seconds=ttl_seconds, run_id=run_id
+        )
 
     async def make(
         self,
         region: Optional[str] = None,
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
+        run_id: Optional[str] = None,
     ):
         """Create an environment instance with task's configuration.
 
@@ -233,11 +237,13 @@ class Task(BaseModel):
         - env_key (env_id + version)
         - data_key (data_id + data_version, if present)
         - env_variables (if present)
+        - run_id (if present)
 
         Args:
             region: Optional AWS region for the environment
             image_type: Optional image type for the environment
             ttl_seconds: Optional TTL in seconds for the instance
+            run_id: Optional run ID to group instances
 
         Returns:
             Environment instance configured for this task
@@ -245,7 +251,7 @@ class Task(BaseModel):
         Example:
             task = fleet.Task(key="my-task", prompt="...", env_id="my-env",
                             data_id="my-data", data_version="v1.0")
-            env = await task.make(region="us-west-2")
+            env = await task.make(region="us-west-2", run_id="my-batch-123")
         """
         if not self.env_id:
             raise ValueError("Task has no env_id defined")
@@ -260,6 +266,7 @@ class Task(BaseModel):
             env_variables=self.env_variables if self.env_variables else None,
             image_type=image_type,
             ttl_seconds=ttl_seconds,
+            run_id=run_id,
         )
 
 
@@ -279,14 +286,17 @@ def verifier_from_string(
     """
     try:
         import inspect
+        import re
         from .verifiers.verifier import AsyncVerifierFunction
         from fleet.verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
         from fleet.verifiers.db import IgnoreConfig
-        from fleet.verifiers.parsing import parse_and_validate_verifier
 
-        # Validate the code and extract function name
-        # This ensures no arbitrary code execution during import
-        func_name = parse_and_validate_verifier(verifier_func)
+        # Strip @verifier decorator if present to avoid double-wrapping
+        # Remove lines like: @verifier(key="...")
+        cleaned_code = re.sub(r"@verifier\([^)]*\)\s*\n", "", verifier_func)
+        # Also remove the verifier import if present
+        cleaned_code = re.sub(r"from fleet import.*verifier.*\n", "", cleaned_code)
+        cleaned_code = re.sub(r"import.*verifier.*\n", "", cleaned_code)
 
         # Create a local namespace for executing the code
         local_namespace = {
@@ -296,18 +306,20 @@ def verifier_from_string(
             "Environment": object,  # Add Environment type if needed
         }
 
-        # Execute the verifier code in the namespace
-        # This is now safe because we validated it contains only declarative code
-        exec(verifier_func, globals(), local_namespace)
+        # Execute the cleaned verifier code in the namespace
+        exec(cleaned_code, globals(), local_namespace)
 
-        # Get the function by the parsed function name
-        func_obj = local_namespace.get(func_name)
+        # Find the function that was defined (not imported)
+        # Functions defined via exec have co_filename == '<string>'
+        # Imported functions have their actual module file path
+        func_obj = None
+        for name, obj in local_namespace.items():
+            if inspect.isfunction(obj) and obj.__code__.co_filename == "<string>":
+                func_obj = obj
+                break
 
         if func_obj is None:
-            raise ValueError(f"Function '{func_name}' not found in verifier code")
-
-        if not inspect.isfunction(func_obj):
-            raise ValueError(f"'{func_name}' is not a function")
+            raise ValueError("No function found in verifier code")
 
         # Create an AsyncVerifierFunction instance with raw code
         verifier_instance = AsyncVerifierFunction(
@@ -381,7 +393,7 @@ async def load_tasks(
 
 
 async def update_task(
-    task_key: str, prompt: Optional[str] = None, verifier_code: Optional[str] = None
+    task_key: str, prompt: Optional[str] = None, verifier_code: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None
 ):
     """Convenience function to update an existing task.
 
@@ -389,6 +401,7 @@ async def update_task(
         task_key: The key of the task to update
         prompt: New prompt text for the task (optional)
         verifier_code: Python code for task verification (optional)
+        metadata: Additional metadata for the task (optional)
 
     Returns:
         TaskResponse containing the updated task details
@@ -396,16 +409,19 @@ async def update_task(
     Examples:
         response = await fleet.update_task("my-task", prompt="New prompt text")
         response = await fleet.update_task("my-task", verifier_code="def verify(env): return True")
+        response = await fleet.update_task("my-task", metadata={"seed": 42, "story": "Updated story"})
     """
     from .global_client import get_client
 
     client = get_client()
     return await client.update_task(
-        task_key=task_key, prompt=prompt, verifier_code=verifier_code
+        task_key=task_key, prompt=prompt, verifier_code=verifier_code, metadata=metadata
     )
 
 
-async def get_task(task_key: str, version_id: Optional[str] = None, team_id: Optional[str] = None):
+async def get_task(
+    task_key: str, version_id: Optional[str] = None, team_id: Optional[str] = None
+):
     """Convenience function to get a task by key and optional version.
 
     Args:
@@ -424,7 +440,9 @@ async def get_task(task_key: str, version_id: Optional[str] = None, team_id: Opt
     from .global_client import get_client
 
     client = get_client()
-    return await client.get_task(task_key=task_key, version_id=version_id, team_id=team_id)
+    return await client.get_task(
+        task_key=task_key, version_id=version_id, team_id=team_id
+    )
 
 
 async def import_task(task: Task, project_key: Optional[str] = None):

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/fleet/client.py

@@ -212,6 +212,7 @@ class Fleet:
         env_variables: Optional[Dict[str, Any]] = None,
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
+        run_id: Optional[str] = None,
     ) -> SyncEnv:
         if ":" in env_key:
             env_key_part, env_version = env_key.split(":", 1)
@@ -247,6 +248,7 @@ class Fleet:
             image_type=image_type,
             created_from="sdk",
             ttl_seconds=ttl_seconds,
+            run_id=run_id,
         )
 
         # Only use region-specific base URL if no custom base URL is set
@@ -269,13 +271,15 @@ class Fleet:
         return self.make(env_key=f"{task.env_id}:{task.version}")
 
     def instances(
-        self, status: Optional[str] = None, region: Optional[str] = None
+        self, status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None
     ) -> List[SyncEnv]:
         params = {}
         if status:
             params["status"] = status
         if region:
             params["region"] = region
+        if run_id:
+            params["run_id"] = run_id
 
         response = self.client.request("GET", "/v1/env/instances", params=params)
         return [
@@ -300,6 +304,28 @@ class Fleet:
     def delete(self, instance_id: str) -> InstanceResponse:
         return _delete_instance(self.client, instance_id)
 
+    def close(self, instance_id: str) -> InstanceResponse:
+        """Close (delete) a specific instance by ID.
+        
+        Args:
+            instance_id: The instance ID to close
+            
+        Returns:
+            InstanceResponse containing the deleted instance details
+        """
+        return _delete_instance(self.client, instance_id)
+
+    def close_all(self, run_id: str) -> List[InstanceResponse]:
+        """Close (delete) all instances associated with a run_id.
+        
+        Args:
+            run_id: The run ID whose instances should be closed
+            
+        Returns:
+            List[InstanceResponse] containing the deleted instances
+        """
+        return _delete_instances_by_run_id(self.client, run_id)
+
     def load_tasks_from_file(self, filename: str) -> List[Task]:
         with open(filename, "r", encoding="utf-8") as f:
             tasks_data = f.read()
@@ -559,7 +585,7 @@ class Fleet:
                 env_variables=task_response.env_variables or {},
                 verifier_func=verifier_func,  # Set verifier code
                 verifier=verifier,  # Use created verifier or None
-                metadata={},  # Default empty metadata
+                metadata=task_response.metadata or {},
                 output_json_schema=getattr(task_response, "output_json_schema", None),  # Get output_json_schema if available
             )
             tasks.append(task)
@@ -706,6 +732,7 @@ class Fleet:
         task_key: str,
         prompt: Optional[str] = None,
         verifier_code: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> TaskResponse:
         """Update an existing task.
 
@@ -713,11 +740,12 @@ class Fleet:
             task_key: The key of the task to update
             prompt: New prompt text for the task (optional)
             verifier_code: Python code for task verification (optional)
+            metadata: Additional metadata for the task (optional)
 
         Returns:
             TaskResponse containing the updated task details
         """
-        payload = TaskUpdateRequest(prompt=prompt, verifier_code=verifier_code)
+        payload = TaskUpdateRequest(prompt=prompt, verifier_code=verifier_code, metadata=metadata)
         response = self.client.request(
             "PUT", f"/v1/tasks/{task_key}", json=payload.model_dump(exclude_none=True)
         )
@@ -808,6 +836,11 @@ def _delete_instance(client: SyncWrapper, instance_id: str) -> InstanceResponse:
     return InstanceResponse(**response.json())
 
 
+def _delete_instances_by_run_id(client: SyncWrapper, run_id: str) -> List[InstanceResponse]:
+    response = client.request("DELETE", f"/v1/env/instances/run/{run_id}")
+    return [InstanceResponse(**instance_data) for instance_data in response.json()]
+
+
 def _check_bundle_exists(
     client: SyncWrapper, bundle_hash: str
 ) -> VerifiersCheckResponse:

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/fleet/env/__init__.py

@@ -7,6 +7,8 @@ from .client import (
     list_regions,
     get,
     list_instances,
+    close,
+    close_all,
     account,
 )
 
@@ -17,6 +19,8 @@ from .._async.env.client import (
     list_regions_async,
     get_async,
     list_instances_async,
+    close_async,
+    close_all_async,
     account_async,
 )
 
@@ -27,11 +31,15 @@ __all__ = [
     "list_regions",
     "list_instances",
     "get",
+    "close",
+    "close_all",
     "make_async",
     "list_envs_async",
     "list_regions_async",
     "list_instances_async",
     "get_async",
+    "close_async",
+    "close_all_async",
     "account",
     "account_async",
 ]

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/fleet/env/client.py

@@ -1,5 +1,5 @@
 from ..client import Fleet, SyncEnv, Task
-from ..models import Environment as EnvironmentModel, AccountResponse
+from ..models import Environment as EnvironmentModel, AccountResponse, InstanceResponse
 from typing import List, Optional, Dict, Any
 
 
@@ -10,6 +10,7 @@ def make(
     env_variables: Optional[Dict[str, Any]] = None,
     image_type: Optional[str] = None,
     ttl_seconds: Optional[int] = None,
+    run_id: Optional[str] = None,
 ) -> SyncEnv:
     return Fleet().make(
         env_key,
@@ -18,6 +19,7 @@ def make(
         env_variables=env_variables,
         image_type=image_type,
         ttl_seconds=ttl_seconds,
+        run_id=run_id,
     )
 
 
@@ -34,14 +36,38 @@ def list_regions() -> List[str]:
 
 
 def list_instances(
-    status: Optional[str] = None, region: Optional[str] = None
+    status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None
 ) -> List[SyncEnv]:
-    return Fleet().instances(status=status, region=region)
+    return Fleet().instances(status=status, region=region, run_id=run_id)
 
 
 def get(instance_id: str) -> SyncEnv:
     return Fleet().instance(instance_id)
 
 
+def close(instance_id: str) -> InstanceResponse:
+    """Close (delete) a specific instance by ID.
+    
+    Args:
+        instance_id: The instance ID to close
+        
+    Returns:
+        InstanceResponse containing the deleted instance details
+    """
+    return Fleet().close(instance_id)
+
+
+def close_all(run_id: str) -> List[InstanceResponse]:
+    """Close (delete) all instances associated with a run_id.
+    
+    Args:
+        run_id: The run ID whose instances should be closed
+        
+    Returns:
+        List[InstanceResponse] containing the deleted instances
+    """
+    return Fleet().close_all(run_id)
+
+
 def account() -> AccountResponse:
     return Fleet().account()

{fleet_python-0.2.66b4 → fleet_python-0.2.68}/fleet/models.py

@@ -51,6 +51,7 @@ class Instance(BaseModel):
     team_id: str = Field(..., title="Team Id")
     region: str = Field(..., title="Region")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
+    run_id: Optional[str] = Field(None, title="Run Id")
 
 
 class InstanceRequest(BaseModel):
@@ -158,6 +159,7 @@ class TaskRequest(BaseModel):
     verifier_id: Optional[str] = Field(None, title="Verifier Id")
     version: Optional[str] = Field(None, title="Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
+    metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
     output_json_schema: Optional[Dict[str, Any]] = Field(
         None, title="Output Json Schema"
     )
@@ -166,6 +168,7 @@ class TaskRequest(BaseModel):
 class TaskUpdateRequest(BaseModel):
     prompt: Optional[str] = Field(None, title="Prompt")
     verifier_code: Optional[str] = Field(None, title="Verifier Code")
+    metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
 
 
 class VerifierData(BaseModel):
@@ -191,6 +194,7 @@ class TaskResponse(BaseModel):
     data_version: Optional[str] = Field(None, title="Data Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
     verifier: Optional[VerifierData] = Field(None, title="Verifier")
+    metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
     output_json_schema: Optional[Dict[str, Any]] = Field(
         None, title="Output Json Schema"
     )
@@ -360,6 +364,7 @@ class InstanceResponse(BaseModel):
     data_version: Optional[str] = Field(None, title="Data Version")
     urls: Optional[InstanceURLs] = Field(None, title="Urls")
     health: Optional[bool] = Field(None, title="Health")
+    run_id: Optional[str] = Field(None, title="Run Id")
 
 
 class AccountResponse(BaseModel):