fleet-python 0.2.66b2__py3-none-any.whl → 0.2.105__py3-none-any.whl

fleet/client.py

@@ -17,11 +17,18 @@
 import base64
 import cloudpickle
 import concurrent.futures
+import dataclasses
 import httpx
 import json
 import logging
 import os
-from typing import List, Optional, Dict, Any, TYPE_CHECKING
+from datetime import date, datetime
+from decimal import Decimal
+from enum import Enum
+from pathlib import Path
+from typing import List, Optional, Dict, Any, TYPE_CHECKING, Union
+from urllib.parse import urlparse
+from uuid import UUID
 
 from .base import EnvironmentBase, SyncWrapper
 from .models import (
@@ -35,18 +42,130 @@ from .models import (
     TaskRequest,
     TaskResponse,
     TaskUpdateRequest,
+    Run,
+    HeartbeatResponse,
+    JobCreateRequest,
+    JobResponse,
+    JobListResponse,
+    JobCreateResponse,
+    JobSessionsResponse,
+    SessionTranscriptResponse,
+    SessionIngestRequest,
+    SessionIngestMessage,
+    SessionIngestResponse,
+    SessionStatus,
 )
 from .tasks import Task
 
 if TYPE_CHECKING:
     from .verifiers import SyncVerifierFunction
 
+
+def _json_default(x: Any) -> Any:
+    """Default JSON serializer for non-native types."""
+    if isinstance(x, (datetime, date)):
+        return x.isoformat()
+    if isinstance(x, (UUID, Path)):
+        return str(x)
+    if isinstance(x, Decimal):
+        return float(x)
+    if isinstance(x, Enum):
+        return x.value
+    if isinstance(x, bytes):
+        return base64.b64encode(x).decode("utf-8")
+    if isinstance(x, set):
+        return list(x)
+    if dataclasses.is_dataclass(x) and not isinstance(x, type):
+        return dataclasses.asdict(x)
+    # Handle objects with __dict__ (generic objects)
+    if hasattr(x, "__dict__"):
+        return x.__dict__
+    raise TypeError(f"Not JSON serializable: {type(x)}")
+
+
+def _to_dict(obj: Any) -> Any:
+    """Convert any object to a JSON-serializable dict/value.
+
+    Handles:
+    - Pydantic v2 models (model_dump)
+    - Pydantic v1 models (.dict())
+    - dataclasses (asdict)
+    - TypedDict (just dict at runtime)
+    - Objects with __dict__
+    - Primitives pass through
+    """
+    if obj is None:
+        return None
+
+    # Pydantic v2
+    if hasattr(obj, "model_dump"):
+        return obj.model_dump()
+
+    # Pydantic v1
+    if hasattr(obj, "dict") and callable(obj.dict):
+        return obj.dict()
+
+    # dataclass
+    if dataclasses.is_dataclass(obj) and not isinstance(obj, type):
+        return dataclasses.asdict(obj)
+
+    # Already a dict or list - recursively convert
+    if isinstance(obj, dict):
+        return {k: _to_dict(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_to_dict(v) for v in obj]
+
+    # Primitives
+    if isinstance(obj, (str, int, float, bool, type(None))):
+        return obj
+
+    # bytes -> base64
+    if isinstance(obj, bytes):
+        return base64.b64encode(obj).decode("utf-8")
+
+    # datetime/date
+    if isinstance(obj, (datetime, date)):
+        return obj.isoformat()
+
+    # UUID, Path
+    if isinstance(obj, (UUID, Path)):
+        return str(obj)
+
+    # Enum
+    if isinstance(obj, Enum):
+        return obj.value
+
+    # Decimal
+    if isinstance(obj, Decimal):
+        return float(obj)
+
+    # set
+    if isinstance(obj, set):
+        return list(obj)
+
+    # Generic object with __dict__
+    if hasattr(obj, "__dict__"):
+        return {k: _to_dict(v) for k, v in obj.__dict__.items() if not k.startswith("_")}
+
+    # Fallback - try to convert, or return string representation
+    try:
+        json.dumps(obj)
+        return obj
+    except (TypeError, ValueError):
+        return str(obj)
+
+
 from .instance import (
     InstanceClient,
     ResetRequest,
     ResetResponse,
     ExecuteFunctionResponse,
 )
+from .instance.models import (
+    Resource as ResourceModel,
+    ResourceType,
+    ResourceMode,
+)
 from .config import (
     DEFAULT_MAX_RETRIES,
     DEFAULT_TIMEOUT,
@@ -59,16 +178,183 @@ from .resources.base import Resource
 from .resources.sqlite import SQLiteResource
 from .resources.browser import BrowserResource
 from .resources.mcp import SyncMCPResource
+from .resources.api import APIResource
 
 logger = logging.getLogger(__name__)
 
 
+class Session:
+    """A session for logging agent interactions to Fleet.
+
+    This provides a simple interface for streaming messages during an agent run.
+    Messages are sent one-by-one as they happen.
+
+    Usage:
+        session = fleet.session(job_id=job_id)
+
+        # Log LLM calls
+        session.log(history, response)
+
+        # Complete when done
+        session.complete()  # or session.fail()
+    """
+
+    def __init__(
+        self,
+        client: "Fleet",
+        session_id: Optional[str] = None,
+        job_id: Optional[str] = None,
+        config: Optional[Any] = None,
+        model: Optional[str] = None,
+        task_key: Optional[str] = None,
+        instance_id: Optional[str] = None,
+    ):
+        self.session_id = session_id
+        self.job_id = job_id
+        self.config = config
+        self.model = model
+        self.task_key = task_key
+        self.instance_id = instance_id
+        self._client = client
+        self._message_count = 0
+        self._logged_count = 0  # Track how many messages from history have been logged
+        self._config_sent = False  # Only send config/model/task_key/instance_id on first log
+
+    def log(self, history: List[Any], response: Any) -> "SessionIngestResponse":
+        """Log an LLM call to the session.
+
+        Pass the input history and the model response. The session tracks what's
+        already been logged and only sends new messages. Objects are automatically
+        serialized to JSON (supports Pydantic, dataclasses, TypedDict, etc.).
+
+        Example:
+            response = model.generate(history)
+            session.log(history, response.content)
+
+        Args:
+            history: The input messages sent to the model
+            response: The model's response (any serializable object)
+
+        Returns:
+            SessionIngestResponse with updated message count
+        """
+        from .models import SessionIngestResponse
+
+        # Collect new history messages since last call
+        new_history = history[self._logged_count:]
+
+        # Update tracked count to include the response we're about to send
+        # This prevents the response from being sent again as "new history" in the next call
+        self._logged_count = len(history) + (1 if response is not None else 0)
+
+        # Build the payload - serialize history + response to JSON
+        payload: Dict[str, Any] = {
+            "history": [_to_dict(msg) for msg in new_history],
+            "response": _to_dict(response),
+        }
+        if self.session_id:
+            payload["session_id"] = self.session_id
+        if self.job_id:
+            payload["job_id"] = self.job_id
+        # Include config, model, task_key, instance_id on first log only
+        if not self._config_sent:
+            if self.config is not None:
+                payload["config"] = _to_dict(self.config)
+            if self.model is not None:
+                payload["model"] = self.model
+            if self.task_key is not None:
+                payload["task_key"] = self.task_key
+            if self.instance_id is not None:
+                payload["instance_id"] = self.instance_id
+            self._config_sent = True
+
+        if not new_history and response is None:
+            return SessionIngestResponse(
+                success=True,
+                session_id=self.session_id or "",
+                message_count=self._message_count,
+                created_new_session=False,
+            )
+
+        result = self._client._ingest_raw(payload=payload)
+        self._message_count = result.message_count
+        # Update session_id if this was the first log (new session created)
+        if not self.session_id and result.session_id:
+            self.session_id = result.session_id
+        return result
+
+    def complete(
+        self,
+        verifier_execution_id: Optional[str] = None,
+    ) -> "SessionIngestResponse":
+        """Mark the session as completed successfully.
+
+        Args:
+            verifier_execution_id: Optional ID of the verifier execution record
+
+        Returns:
+            SessionIngestResponse with final state
+        """
+        from datetime import datetime
+
+        payload: Dict[str, Any] = {
+            "session_id": self.session_id,
+            "status": "completed",
+            "ended_at": datetime.now().isoformat(),
+        }
+        if verifier_execution_id:
+            payload["verifier_execution_id"] = verifier_execution_id
+
+        response = self._client._ingest_raw(payload)
+        self._message_count = response.message_count
+        return response
+
+    def fail(
+        self,
+        verifier_execution_id: Optional[str] = None,
+    ) -> "SessionIngestResponse":
+        """Mark the session as failed.
+
+        Args:
+            verifier_execution_id: Optional ID of the verifier execution record
+
+        Returns:
+            SessionIngestResponse with final state
+        """
+        from datetime import datetime
+
+        payload: Dict[str, Any] = {
+            "session_id": self.session_id,
+            "status": "failed",
+            "ended_at": datetime.now().isoformat(),
+        }
+        if verifier_execution_id:
+            payload["verifier_execution_id"] = verifier_execution_id
+
+        response = self._client._ingest_raw(payload)
+        self._message_count = response.message_count
+        return response
+
+    @property
+    def message_count(self) -> int:
+        """Get the current message count."""
+        return self._message_count
+
+
 class SyncEnv(EnvironmentBase):
     def __init__(self, client: Optional[SyncWrapper], **kwargs):
         super().__init__(**kwargs)
         self._client = client
         self._apps: Dict[str, InstanceClient] = {}
         self._instance: Optional[InstanceClient] = None
+        self._manager_url_override: Optional[str] = None  # For URL mode
+
+    @property
+    def manager_url(self) -> str:
+        """Override to support URL mode where urls is None."""
+        if self._manager_url_override is not None:
+            return self._manager_url_override
+        return super().manager_url
 
     @property
     def instance(self) -> InstanceClient:
@@ -80,17 +366,17 @@ class SyncEnv(EnvironmentBase):
 
     def app(self, name: str) -> InstanceClient:
         if name not in self._apps:
-            # Extract base URL by removing the current app path (e.g., /sentry/api/v1/env)
-            # manager_url looks like: https://xxx.fleetai.com/sentry/api/v1/env
-            base_url = self.manager_url.split("/api/v1/env")[0]
-            # Remove the current app name (e.g., /sentry) to get the root
-            if "/" in base_url:
-                parts = base_url.rsplit("/", 1)
-                if len(parts) == 2 and parts[0] != "https:/":
-                    base_url = parts[0]
+            # Extract scheme://netloc from manager_url, then construct /{name}/api/v1/env
+            # Supports all URL formats:
+            #   https://host/api/v1/env -> https://host/{name}/api/v1/env
+            #   https://host/sentry/api/v1/env -> https://host/{name}/api/v1/env
+            #   http://localhost:8080/api/v1/env -> http://localhost:8080/{name}/api/v1/env
+            parsed = urlparse(self.manager_url)
+            root = f"{parsed.scheme}://{parsed.netloc}"
+            new_url = f"{root}/{name}/api/v1/env"
 
             self._apps[name] = InstanceClient(
-                f"{base_url}/{name}/api/v1/env",
+                new_url,
                 self._client.httpx_client if self._client else None,
             )
         return self._apps[name]
@@ -112,6 +398,29 @@ class SyncEnv(EnvironmentBase):
     def browser(self, name: str = "cdp") -> BrowserResource:
         return self.instance.browser(name)
 
+    def api(self, name: str = "api") -> APIResource:
+        """Get an API resource for making HTTP requests to the app's API.
+
+        Args:
+            name: Name for the API resource (default: "api")
+
+        Returns:
+            APIResource for making HTTP requests
+        """
+        # Use urls.api if available, otherwise fall back to urls.root + "/raw"
+        if self.urls and self.urls.api:
+            base_url = self.urls.api
+        elif self.urls and self.urls.root:
+            base_url = f"{self.urls.root.rstrip('/')}/raw"
+        elif self._manager_url_override and self._manager_url_override != "local://":
+            # URL mode: strip /api/v1/env suffix to get root URL
+            base_url = self._manager_url_override.rstrip('/')
+            if base_url.endswith('/api/v1/env'):
+                base_url = base_url[:-len('/api/v1/env')]
+        else:
+            raise ValueError("No API URL configured for this environment")
+        return self.instance.api(name, base_url)
+
     @property
     def mcp(self) -> SyncMCPResource:
         mcp_url = f"{self.urls.root}mcp"
@@ -126,6 +435,23 @@ class SyncEnv(EnvironmentBase):
     def close(self) -> InstanceResponse:
         return _delete_instance(self._load_client, self.instance_id)
 
+    def heartbeat(self) -> HeartbeatResponse:
+        """Send heartbeat to keep instance alive (if heartbeat monitoring is enabled).
+        
+        Returns:
+            HeartbeatResponse containing heartbeat status and deadline information
+        """
+        body = {}
+        if self.heartbeat_region:
+            body["region"] = self.heartbeat_region
+        
+        response = self._load_client.request(
+            "POST", 
+            f"/v1/env/instances/{self.instance_id}/heartbeat",
+            json=body
+        )
+        return HeartbeatResponse(**response.json())
+
     def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
         return self.instance.verify(validator)
 
@@ -148,6 +474,7 @@ class SyncEnv(EnvironmentBase):
         kwargs: dict,
         timeout: Optional[int] = 30,
         needs_upload: bool = True,
+        verifier_runtime_version: Optional[str] = None,
     ) -> VerifiersExecuteResponse:
         return _execute_verifier_remote(
             self._load_client,
@@ -160,6 +487,7 @@ class SyncEnv(EnvironmentBase):
             kwargs,
             timeout,
             needs_upload,
+            verifier_runtime_version,
         )
 
     def __getstate__(self):
@@ -212,6 +540,8 @@ class Fleet:
         env_variables: Optional[Dict[str, Any]] = None,
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
+        run_id: Optional[str] = None,
+        heartbeat_interval: Optional[int] = None,
     ) -> SyncEnv:
         if ":" in env_key:
             env_key_part, env_version = env_key.split(":", 1)
@@ -247,6 +577,8 @@ class Fleet:
             image_type=image_type,
             created_from="sdk",
             ttl_seconds=ttl_seconds,
+            run_id=run_id,
+            heartbeat_interval=heartbeat_interval,
         )
 
         # Only use region-specific base URL if no custom base URL is set
@@ -269,13 +601,17 @@ 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, profile_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
+        if profile_id:
+            params["profile_id"] = profile_id
 
         response = self.client.request("GET", "/v1/env/instances", params=params)
         return [
@@ -283,11 +619,165 @@ class Fleet:
             for instance_data in response.json()
         ]
 
-    def instance(self, instance_id: str) -> SyncEnv:
-        response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        instance = SyncEnv(client=self.client, **response.json())
-        instance.instance.load()
-        return instance
+    def instance(self, instance_id: Union[str, Dict[str, str]]) -> SyncEnv:
+        """Create or connect to an environment instance.
+
+        Supports three modes based on input type:
+        1. dict: Local filesystem mode - {"current": "./data.db", "seed": "./seed.db"}
+        2. str starting with http:// or https://: Localhost/URL mode
+        3. str (other): Remote cloud instance mode
+
+        Args:
+            instance_id: Instance identifier (str), URL (str starting with http://),
+                        or local db mapping (dict)
+
+        Returns:
+            SyncEnv: Environment instance
+        """
+        # Local filesystem mode - dict of resource names to file paths
+        if isinstance(instance_id, dict):
+            return self._create_local_instance(instance_id)
+
+        # Localhost/direct URL mode - string starting with http:// or https://
+        elif isinstance(instance_id, str) and instance_id.startswith(("http://", "https://")):
+            return self._create_url_instance(instance_id)
+
+        # Remote mode - existing behavior
+        else:
+            response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
+            instance = SyncEnv(client=self.client, **response.json())
+            instance.instance.load()
+            return instance
+
+    def _create_url_instance(self, base_url: str) -> SyncEnv:
+        """Create instance connected to a direct URL (localhost or custom).
+
+        Args:
+            base_url: URL of the instance manager API
+
+        Returns:
+            SyncEnv: Environment instance configured for URL mode
+        """
+        instance_client = InstanceClient(url=base_url, httpx_client=self._httpx_client)
+
+        # Create a minimal environment for URL mode
+        env = SyncEnv(
+            client=self.client,
+            instance_id=base_url,
+            env_key="localhost",
+            version="",
+            status="running",
+            subdomain="localhost",
+            created_at="",
+            updated_at="",
+            terminated_at=None,
+            team_id="",
+            region="localhost",
+            env_variables=None,
+            data_key=None,
+            data_version=None,
+            urls=None,
+            health=None,
+        )
+        env._instance = instance_client
+        env._manager_url_override = base_url  # Set manager_url for URL mode
+        return env
+
+    @staticmethod
+    def _normalize_db_path(path: str) -> tuple[str, bool]:
+        """Normalize database path and detect if it's in-memory.
+
+        Args:
+            path: Database path - can be:
+                  - File path: "./data.db"
+                  - Plain memory: ":memory:"
+                  - Named memory: ":memory:namespace"
+                  - URI: "file:name?mode=memory&cache=shared"
+
+        Returns:
+            Tuple of (normalized_path, is_memory)
+        """
+        import uuid
+        import sqlite3
+
+        if path == ":memory:":
+            # Plain :memory: - create unique namespace
+            name = f"mem_{uuid.uuid4().hex[:8]}"
+            return f"file:{name}?mode=memory&cache=shared", True
+        elif path.startswith(":memory:"):
+            # Named memory: :memory:current -> file:current?mode=memory&cache=shared
+            namespace = path[8:]  # Remove ":memory:" prefix
+            return f"file:{namespace}?mode=memory&cache=shared", True
+        elif "mode=memory" in path:
+            # Already a proper memory URI
+            return path, True
+        else:
+            # Regular file path
+            return path, False
+
+    def _create_local_instance(self, dbs: Dict[str, str]) -> SyncEnv:
+        """Create instance with local file-based or in-memory SQLite resources.
+
+        Args:
+            dbs: Map of resource names to paths (e.g., {"current": "./data.db"} or
+                 {"current": ":memory:current"})
+
+        Returns:
+            SyncEnv: Environment instance configured for local mode
+        """
+        import sqlite3
+
+        instance_client = InstanceClient(url="local://", httpx_client=None)
+        instance_client._resources = []  # Mark as loaded
+        instance_client._memory_anchors = {}  # Store anchor connections for in-memory DBs
+
+        # Store creation parameters for local SQLiteResources
+        # This allows db() to create new instances each time (matching HTTP mode behavior)
+        for name, path in dbs.items():
+            # Normalize path and detect if it's in-memory
+            normalized_path, is_memory = self._normalize_db_path(path)
+
+            # Create anchor connection for in-memory databases
+            # This keeps the database alive as long as the env exists
+            if is_memory:
+                anchor_conn = sqlite3.connect(normalized_path, uri=True)
+                instance_client._memory_anchors[name] = anchor_conn
+
+            resource_model = ResourceModel(
+                name=name,
+                type=ResourceType.db,
+                mode=ResourceMode.rw,
+                label=f"Local: {path}",
+            )
+            instance_client._resources_state[ResourceType.db.value][name] = {
+                'type': 'local',
+                'resource_model': resource_model,
+                'db_path': normalized_path,
+                'is_memory': is_memory
+            }
+
+        # Create a minimal environment for local mode
+        env = SyncEnv(
+            client=self.client,
+            instance_id="local",
+            env_key="local",
+            version="",
+            status="running",
+            subdomain="local",
+            created_at="",
+            updated_at="",
+            terminated_at=None,
+            team_id="",
+            region="local",
+            env_variables=None,
+            data_key=None,
+            data_version=None,
+            urls=None,
+            health=None,
+        )
+        env._instance = instance_client
+        env._manager_url_override = "local://"  # Set manager_url for local mode
+        return env
 
     def check_bundle_exists(self, bundle_hash: str) -> VerifiersCheckResponse:
         return _check_bundle_exists(self.client, bundle_hash)
@@ -300,6 +790,65 @@ 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 heartbeat(self, instance_id: str, region: Optional[str] = None) -> HeartbeatResponse:
+        """Send heartbeat to keep instance alive (if heartbeat monitoring is enabled).
+        
+        Args:
+            instance_id: The instance ID to send heartbeat for
+            region: Optional region override for cross-region heartbeats
+            
+        Returns:
+            HeartbeatResponse containing heartbeat status and deadline information
+        """
+        return _send_heartbeat(self.client, instance_id, region)
+
+    def close_all(self, run_id: Optional[str] = None, profile_id: Optional[str] = None) -> List[InstanceResponse]:
+        """Close (delete) instances using the batch delete endpoint.
+        
+        Args:
+            run_id: Optional run ID to filter instances by
+            profile_id: Optional profile ID to filter instances by (use "self" for your own profile)
+            
+        Returns:
+            List[InstanceResponse] containing the deleted instances
+            
+        Note:
+            At least one of run_id or profile_id must be provided.
+        """
+        return _delete_instances_batch(self.client, run_id=run_id, profile_id=profile_id)
+    
+    def list_runs(
+        self, profile_id: Optional[str] = None, status: Optional[str] = "active"
+    ) -> List[Run]:
+        """List all runs (groups of instances by run_id) with aggregated statistics.
+        
+        Args:
+            profile_id: Optional profile ID to filter runs by (use "self" for your own profile)
+            status: Filter by run status - "active" (default), "inactive", or "all"
+            
+        Returns:
+            List[Run] containing run information with instance counts and timestamps
+        """
+        params = {}
+        if profile_id:
+            params["profile_id"] = profile_id
+        if status:
+            params["active"] = status
+            
+        response = self.client.request("GET", "/v1/env/runs", params=params)
+        return [Run(**run_data) for run_data in response.json()]
+
     def load_tasks_from_file(self, filename: str) -> List[Task]:
         with open(filename, "r", encoding="utf-8") as f:
             tasks_data = f.read()
@@ -366,6 +915,11 @@ class Fleet:
         if not verifier_id:
             verifier_id = task_json.get("key", task_json.get("id"))
 
+        # Extract verifier_runtime_version from metadata if present
+        verifier_runtime_version = None
+        if "metadata" in task_json and isinstance(task_json["metadata"], dict):
+            verifier_runtime_version = task_json["metadata"].get("verifier_runtime_version")
+
         try:
             if verifier_id and verifier_code:
                 verifier = self._create_verifier_from_data(
@@ -373,13 +927,14 @@ class Fleet:
                     verifier_key=task_json.get("key", task_json.get("id")),
                     verifier_code=verifier_code,
                     verifier_sha=verifier_sha,
+                    verifier_runtime_version=verifier_runtime_version,
                 )
         except Exception as e:
             error_msg = f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
             if raise_on_verifier_error:
                 raise ValueError(error_msg) from e
-            else:
-                logger.warning(error_msg)
+            # else:
+            #     logger.warning(error_msg)
 
         task = Task(
             key=task_json.get("key", task_json.get("id")),
@@ -396,7 +951,10 @@ class Fleet:
             verifier=verifier,  # Use created verifier or None
             verifier_id=verifier_id,  # Set verifier_id so _rebuild_verifier works
             verifier_sha=verifier_sha,  # Set verifier_sha
+            verifier_runtime_version=verifier_runtime_version,  # Set verifier_runtime_version
             metadata=task_json.get("metadata", {}),  # Default empty metadata
+            writer_metadata=task_json.get("writer_metadata"),  # Writer metadata
+            qa_metadata=task_json.get("qa_metadata"),  # QA metadata
             output_json_schema=task_json.get("output_json_schema"),  # JSON schema for output
         )
         return task
@@ -469,23 +1027,23 @@ class Fleet:
                                 verifier_sha=tr.verifier.sha256,
                             )
                         except Exception as e:
-                            logger.warning(
-                                f"Failed to create verifier {tr.verifier.key}: {e}"
-                            )
+                            # logger.warning(
+                            #     f"Failed to create verifier {tr.verifier.key}: {e}"
+                            # )
                             return None
                     else:
                         # Fallback: try fetching by ID
                         try:
-                            logger.warning(
-                                f"Embedded verifier code missing for {tr.verifier.key} (NoSuchKey). "
-                                f"Attempting to refetch by id {tr.verifier.verifier_id}"
-                            )
+                            # logger.warning(
+                            #     f"Embedded verifier code missing for {tr.verifier.key} (NoSuchKey). "
+                            #     f"Attempting to refetch by id {tr.verifier.verifier_id}"
+                            # )
                             return self._load_verifier(tr.verifier.verifier_id)
                         except Exception as e:
-                            logger.warning(
-                                f"Refetch by verifier id failed for {tr.verifier.key}: {e}. "
-                                "Leaving verifier unset."
-                            )
+                            # logger.warning(
+                            #     f"Refetch by verifier id failed for {tr.verifier.key}: {e}. "
+                            #     "Leaving verifier unset."
+                            # )
                             return None
 
                 # Add the task for parallel execution
@@ -525,7 +1083,7 @@ class Fleet:
                             result = future.result()
                             verifier_results.append(result)
                         except Exception as e:
-                            logger.warning(f"Verifier loading failed: {e}")
+                            # logger.warning(f"Verifier loading failed: {e}")
                             verifier_results.append(None)
 
         # Build tasks with results
@@ -548,6 +1106,21 @@ class Fleet:
                     if not is_embedded_error:
                         verifier_func = embedded_code
 
+            # Extract verifier metadata
+            verifier_id = task_response.verifier_id
+            if not verifier_id and task_response.verifier:
+                verifier_id = task_response.verifier.verifier_id
+            
+            verifier_sha = None
+            if task_response.verifier:
+                verifier_sha = task_response.verifier.sha256
+            
+            # Extract verifier_runtime_version from metadata if present
+            verifier_runtime_version = None
+            metadata = task_response.metadata or {}
+            if isinstance(metadata, dict):
+                verifier_runtime_version = metadata.get("verifier_runtime_version")
+
             task = Task(
                 key=task_response.key,
                 prompt=task_response.prompt,
@@ -559,7 +1132,12 @@ 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
+                verifier_id=verifier_id,  # Set verifier_id
+                verifier_sha=verifier_sha,  # Set verifier_sha
+                verifier_runtime_version=verifier_runtime_version,  # Set verifier_runtime_version
+                metadata=metadata,
+                writer_metadata=getattr(task_response, "writer_metadata", None),  # Writer metadata
+                qa_metadata=getattr(task_response, "qa_metadata", None),  # QA metadata
                 output_json_schema=getattr(task_response, "output_json_schema", None),  # Get output_json_schema if available
             )
             tasks.append(task)
@@ -612,10 +1190,10 @@ class Fleet:
             with open(filename, "w", encoding="utf-8") as f:
                 json.dump(tasks_data, f, indent=2, default=str)
 
-            logger.info(f"Exported {len(tasks)} tasks to {filename}")
+            # logger.info(f"Exported {len(tasks)} tasks to {filename}")
             return filename
         else:
-            logger.info("No tasks found to export")
+            # logger.info("No tasks found to export")
             return None
 
     def import_single_task(self, task: Task, project_key: Optional[str] = None):
@@ -644,7 +1222,7 @@ class Fleet:
             )
             return response
         except Exception as e:
-            logger.error(f"Failed to import task {task.key}: {e}")
+            # logger.error(f"Failed to import task {task.key}: {e}")
             return None
 
     def import_tasks(self, filename: str, project_key: Optional[str] = None):
@@ -706,6 +1284,9 @@ class Fleet:
         task_key: str,
         prompt: Optional[str] = None,
         verifier_code: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        writer_metadata: Optional[Dict[str, Any]] = None,
+        qa_metadata: Optional[Dict[str, Any]] = None,
     ) -> TaskResponse:
         """Update an existing task.
 
@@ -713,11 +1294,20 @@ 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)
+            writer_metadata: Metadata filled by task writer (optional)
+            qa_metadata: Metadata filled by QA reviewer (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,
+            writer_metadata=writer_metadata,
+            qa_metadata=qa_metadata,
+        )
         response = self.client.request(
             "PUT", f"/v1/tasks/{task_key}", json=payload.model_dump(exclude_none=True)
         )
@@ -750,8 +1340,393 @@ class Fleet:
         )
         return TaskResponse(**response.json())
 
+    # Jobs API methods
+
+    def list_jobs(self, team_id: Optional[str] = None) -> List[JobResponse]:
+        """List all jobs for the authenticated team.
+
+        Args:
+            team_id: Optional team_id to filter by (admin only)
+
+        Returns:
+            List[JobResponse] containing job information
+        """
+        params = {}
+        if team_id is not None:
+            params["team_id"] = team_id
+
+        response = self.client.request("GET", "/v1/jobs", params=params)
+        job_list = JobListResponse(**response.json())
+        return job_list.jobs
+
+    def create_job(
+        self,
+        models: List[str],
+        name: Optional[str] = None,
+        pass_k: int = 1,
+        env_key: Optional[str] = None,
+        project_key: Optional[str] = None,
+        task_keys: Optional[List[str]] = None,
+        excluded_task_keys: Optional[List[str]] = None,
+        max_steps: Optional[int] = None,
+        max_duration_minutes: int = 60,
+        max_concurrent_per_model: int = 30,
+        mode: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        model_prompts: Optional[Dict[str, str]] = None,
+        byok_keys: Optional[Dict[str, str]] = None,
+        byok_ttl_minutes: Optional[int] = None,
+        harness: Optional[str] = None,
+    ) -> JobCreateResponse:
+        """Create a new job.
+
+        Args:
+            models: List of model identifiers in "provider/model" format
+            name: Optional job name. Supports placeholders: {id} (UUID), {sid} (short UUID), {i} (auto-increment, must be suffix)
+            pass_k: Number of passes (default: 1)
+            env_key: Environment key (mutually exclusive with project_key/task_keys)
+            project_key: Project key (mutually exclusive with env_key/task_keys)
+            task_keys: Specific task keys (mutually exclusive with env_key/project_key)
+            excluded_task_keys: Task keys to exclude
+            max_steps: Maximum agent steps
+            max_duration_minutes: Timeout in minutes (default: 60)
+            max_concurrent_per_model: Max concurrent per model (default: 30)
+            mode: "tool-use" or "computer-use"
+            system_prompt: Custom system prompt
+            model_prompts: Per-model prompts (model -> prompt)
+            byok_keys: Bring Your Own Keys (provider -> API key)
+            byok_ttl_minutes: TTL for BYOK keys in minutes
+            harness: Harness identifier
+
+        Returns:
+            JobCreateResponse containing job_id, workflow_job_id, status, and name
+        """
+        request = JobCreateRequest(
+            name=name,
+            models=models,
+            pass_k=pass_k,
+            env_key=env_key,
+            project_key=project_key,
+            task_keys=task_keys,
+            excluded_task_keys=excluded_task_keys,
+            max_steps=max_steps,
+            max_duration_minutes=max_duration_minutes,
+            max_concurrent_per_model=max_concurrent_per_model,
+            mode=mode,
+            system_prompt=system_prompt,
+            model_prompts=model_prompts,
+            byok_keys=byok_keys,
+            byok_ttl_minutes=byok_ttl_minutes,
+            harness=harness,
+        )
+
+        response = self.client.request(
+            "POST", "/v1/jobs", json=request.model_dump(exclude_none=True)
+        )
+        return JobCreateResponse(**response.json())
+
+    def get_job(self, job_id: str, team_id: Optional[str] = None) -> JobResponse:
+        """Get a specific job by ID.
+
+        Args:
+            job_id: The job ID
+            team_id: Optional team_id to filter by (admin only)
+
+        Returns:
+            JobResponse containing job information
+        """
+        params = {}
+        if team_id is not None:
+            params["team_id"] = team_id
+
+        response = self.client.request("GET", f"/v1/jobs/{job_id}", params=params)
+        return JobResponse(**response.json())
+
+    # Sessions API methods
+
+    def list_job_sessions(self, job_id: str) -> JobSessionsResponse:
+        """List all sessions for a job, grouped by task.
+
+        Args:
+            job_id: The job ID
+
+        Returns:
+            JobSessionsResponse containing sessions grouped by task with statistics
+        """
+        response = self.client.request("GET", f"/v1/sessions/job/{job_id}")
+        return JobSessionsResponse(**response.json())
+
+    def get_session_transcript(self, session_id: str) -> SessionTranscriptResponse:
+        """Get the transcript for a specific session.
+
+        Args:
+            session_id: The session ID
+
+        Returns:
+            SessionTranscriptResponse containing task, instance, verifier result, and messages
+        """
+        response = self.client.request(
+            "GET", f"/v1/sessions/{session_id}/transcript"
+        )
+        return SessionTranscriptResponse(**response.json())
+
+    def _ingest(
+        self,
+        messages: List[Dict[str, Any]],
+        session_id: Optional[str] = None,
+        model: Optional[str] = None,
+        task_key: Optional[str] = None,
+        job_id: Optional[str] = None,
+        instance_id: Optional[str] = None,
+        status: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        started_at: Optional[str] = None,
+        ended_at: Optional[str] = None,
+        verifier_execution_id: Optional[str] = None,
+    ) -> SessionIngestResponse:
+        """Internal method to ingest session data."""
+        message_objects = [SessionIngestMessage(**msg) for msg in messages]
+        request = SessionIngestRequest(
+            messages=message_objects,
+            session_id=session_id,
+            model=model,
+            task_key=task_key,
+            job_id=job_id,
+            instance_id=instance_id,
+            status=SessionStatus(status) if status else None,
+            metadata=metadata,
+            started_at=started_at,
+            ended_at=ended_at,
+            verifier_execution_id=verifier_execution_id,
+        )
+        response = self.client.request(
+            "POST",
+            "/v1/sessions/ingest",
+            json=request.model_dump(exclude_none=True),
+        )
+        return SessionIngestResponse(**response.json())
+
+    def _ingest_raw(
+        self,
+        payload: Dict[str, Any],
+    ) -> SessionIngestResponse:
+        """Internal method to ingest raw session data as JSON.
+
+        This sends the history and response as-is to the backend,
+        letting the backend handle format normalization.
+        """
+        # Pre-serialize with our custom handler to ensure all types are JSON-safe
+        json_str = json.dumps(payload, default=_json_default)
+        clean_payload = json.loads(json_str)
+
+        response = self.client.request(
+            "POST",
+            "/v1/traces/logs",
+            json=clean_payload,
+        )
+        return SessionIngestResponse(**response.json())
+
+    def start_session(
+        self,
+        session_id: Optional[str] = None,
+        job_id: Optional[str] = None,
+        config: Optional[Any] = None,
+        model: Optional[str] = None,
+        task_key: Optional[str] = None,
+        instance_id: Optional[str] = None,
+    ) -> Session:
+        """Start a new session for logging agent interactions.
+
+        This returns a Session object. The session is created on the backend
+        when you call log() for the first time.
+
+        Args:
+            session_id: Optional existing session ID to resume
+            job_id: Optional job ID to associate with the session
+            config: Optional config object (e.g., GenerateContentConfig) to log
+            model: Optional model name to log
+            task_key: Optional Fleet task key
+            instance_id: Optional Fleet instance ID
+
+        Returns:
+            Session object with log(), complete(), and fail() methods
+
+        Example:
+            session = fleet_client.start_session(config=config, model="gpt-4", task_key="task_123")
+
+            # Log LLM calls during agent run
+            session.log(history, response)
+
+            # Complete when done
+            session.complete()
+        """
+        return Session(
+            client=self,
+            session_id=session_id,
+            job_id=job_id,
+            config=config,
+            model=model,
+            task_key=task_key,
+            instance_id=instance_id,
+        )
+
+    def trace_job(self, name: Optional[str] = None) -> str:
+        """Create a new trace job.
+
+        Args:
+            name: Name of the job (generated server-side if not provided)
+
+        Returns:
+            The job_id string
+        """
+        from .models import TraceJobRequest, TraceJobResponse
+
+        request = TraceJobRequest(name=name)
+        response = self.client.request(
+            "POST",
+            "/v1/traces/jobs",
+            json=request.model_dump(),
+        )
+        result = TraceJobResponse(**response.json())
+        return result.job_id
+
+    def create_session(
+        self,
+        model: Optional[str] = None,
+        task_key: Optional[str] = None,
+        job_id: Optional[str] = None,
+        instance_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        started_at: Optional[str] = None,
+        initial_message: Optional[Dict[str, Any]] = None,
+    ) -> SessionIngestResponse:
+        """Create a new session, optionally with an initial message.
+
+        This is useful for streaming scenarios where you want to create
+        a session first and then append messages one by one.
+
+        Args:
+            model: Model identifier (e.g., "anthropic/claude-sonnet-4")
+            task_key: Task key to associate with the session
+            job_id: Job ID to associate with the session
+            instance_id: Instance ID to associate with the session
+            metadata: Additional metadata for the session
+            started_at: ISO timestamp when session started
+            initial_message: Optional first message dict with 'role' and 'content'
+
+        Returns:
+            SessionIngestResponse containing session_id
+
+        Example:
+            # Create session and get ID
+            session = fleet.create_session(
+                model="anthropic/claude-sonnet-4",
+                task_key="my_task",
+                started_at=datetime.now().isoformat()
+            )
+            
+            # Append messages as they happen
+            fleet.append_message(session.session_id, {"role": "user", "content": "Hello"})
+            fleet.append_message(session.session_id, {"role": "assistant", "content": "Hi!"})
+        """
+        # Use a placeholder message if none provided
+        if initial_message:
+            messages = [initial_message]
+        else:
+            messages = [{"role": "system", "content": "[session created]"}]
+
+        return self._ingest(
+            messages=messages,
+            model=model,
+            task_key=task_key,
+            job_id=job_id,
+            instance_id=instance_id,
+            status="running",
+            metadata=metadata,
+            started_at=started_at,
+        )
+
+    def append_message(
+        self,
+        session_id: str,
+        message: Dict[str, Any],
+        status: Optional[str] = None,
+        ended_at: Optional[str] = None,
+    ) -> SessionIngestResponse:
+        """Append a single message to an existing session.
+
+        This is useful for streaming scenarios where you want to send
+        messages one by one as they happen.
+
+        Args:
+            session_id: The session ID to append to
+            message: Message dict with 'role' and 'content' keys.
+                Optional keys: 'tool_calls', 'tool_call_id', 'timestamp', 'tokens', 'metadata'
+            status: Optional status update ("running", "completed", "failed")
+            ended_at: ISO timestamp when session ended (set when completing)
+
+        Returns:
+            SessionIngestResponse with updated message count
+
+        Example:
+            # Append user message
+            fleet.append_message(session_id, {"role": "user", "content": "What's 2+2?"})
+            
+            # Append assistant response
+            fleet.append_message(session_id, {"role": "assistant", "content": "4"})
+            
+            # Complete the session
+            fleet.append_message(
+                session_id,
+                {"role": "assistant", "content": "Done!"},
+                status="completed",
+                ended_at=datetime.now().isoformat()
+            )
+        """
+        return self._ingest(
+            messages=[message],
+            session_id=session_id,
+            status=status,
+            ended_at=ended_at,
+        )
+
+    def complete_session(
+        self,
+        session_id: str,
+        status: str = "completed",
+        ended_at: Optional[str] = None,
+        final_message: Optional[Dict[str, Any]] = None,
+    ) -> SessionIngestResponse:
+        """Mark a session as complete.
+
+        Args:
+            session_id: The session ID to complete
+            status: Final status ("completed", "failed", "cancelled")
+            ended_at: ISO timestamp when session ended (defaults to now)
+            final_message: Optional final message to append
+
+        Returns:
+            SessionIngestResponse with final state
+        """
+        from datetime import datetime as dt
+        
+        if ended_at is None:
+            ended_at = dt.now().isoformat()
+        
+        if final_message:
+            messages = [final_message]
+        else:
+            messages = [{"role": "system", "content": f"[session {status}]"}]
+
+        return self._ingest(
+            messages=messages,
+            session_id=session_id,
+            status=status,
+            ended_at=ended_at,
+        )
+
     def _create_verifier_from_data(
-        self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str
+        self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str, verifier_runtime_version: Optional[str] = None
     ) -> "SyncVerifierFunction":
         """Create an AsyncVerifierFunction from verifier data.
 
@@ -773,6 +1748,7 @@ class Fleet:
             verifier_id=verifier_id,
             verifier_key=verifier_key,
             sha256=verifier_sha,
+            verifier_runtime_version=verifier_runtime_version or "",
         )
 
         # Store the original verifier code for reference
@@ -808,6 +1784,37 @@ def _delete_instance(client: SyncWrapper, instance_id: str) -> InstanceResponse:
     return InstanceResponse(**response.json())
 
 
+def _send_heartbeat(client: SyncWrapper, instance_id: str, region: Optional[str] = None) -> HeartbeatResponse:
+    """Send heartbeat to keep instance alive."""
+    body = {}
+    if region:
+        body["region"] = region
+    
+    response = client.request(
+        "POST",
+        f"/v1/env/instances/{instance_id}/heartbeat",
+        json=body
+    )
+    return HeartbeatResponse(**response.json())
+
+
+def _delete_instances_batch(
+    client: SyncWrapper, run_id: Optional[str] = None, profile_id: Optional[str] = None
+) -> List[InstanceResponse]:
+    """Delete instances using the batch endpoint with flexible filtering."""
+    params = {}
+    if run_id:
+        params["run_id"] = run_id
+    if profile_id:
+        params["profile_id"] = profile_id
+    
+    if not params:
+        raise ValueError("At least one of run_id or profile_id must be provided")
+    
+    response = client.request("DELETE", "/v1/env/instances/batch", params=params)
+    return [InstanceResponse(**instance_data) for instance_data in response.json()]
+
+
 def _check_bundle_exists(
     client: SyncWrapper, bundle_hash: str
 ) -> VerifiersCheckResponse:
@@ -826,6 +1833,7 @@ def _execute_verifier_remote(
     kwargs: dict,
     timeout: Optional[int] = 30,
     needs_upload: bool = True,
+    verifier_runtime_version: Optional[str] = None,
 ) -> VerifiersExecuteResponse:
     # Pickle args and kwargs together
     # The first arg should be None as a placeholder for env
@@ -849,18 +1857,22 @@ def _execute_verifier_remote(
         bundle_b64 = base64.b64encode(bundle_data).decode("utf-8")
         request_data["bundle"] = bundle_b64
 
+    # Add verifier_runtime_version if present
+    if verifier_runtime_version:
+        request_data["verifier_runtime_version"] = verifier_runtime_version
+
     # Debug logging
-    logger.debug(
-        f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"
-    )
-    logger.debug(f"Request has bundle: {needs_upload}")
-    logger.debug(f"Using client with base_url: {client.base_url}")
-    logger.debug(f"Request data keys: {list(request_data.keys())}")
-    logger.debug(
-        f"Bundle size: {len(request_data.get('bundle', ''))} chars"
-        if "bundle" in request_data
-        else "No bundle"
-    )
+    # logger.debug(
+    #     f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"
+    # )
+    # logger.debug(f"Request has bundle: {needs_upload}")
+    # logger.debug(f"Using client with base_url: {client.base_url}")
+    # logger.debug(f"Request data keys: {list(request_data.keys())}")
+    # logger.debug(
+    #     f"Bundle size: {len(request_data.get('bundle', ''))} chars"
+    #     if "bundle" in request_data
+    #     else "No bundle"
+    # )
 
     # Note: This should be called on the instance URL, not the orchestrator
     # The instance has manager URLs for verifier execution
@@ -868,6 +1880,6 @@ def _execute_verifier_remote(
 
     # Debug the response
     response_json = response.json()
-    logger.debug(f"Verifier execute response: {response_json}")
+    # logger.debug(f"Verifier execute response: {response_json}")
 
     return VerifiersExecuteResponse(**response_json)