futurehouse-client 0.3.20.dev225__py3-none-any.whl → 0.3.20.dev266__py3-none-any.whl

futurehouse_client/clients/rest_client.py

@@ -14,6 +14,7 @@ import time
 import uuid
 from collections.abc import Collection
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from http import HTTPStatus
 from pathlib import Path
 from types import ModuleType
 from typing import Any, ClassVar, cast
@@ -54,9 +55,14 @@ from futurehouse_client.models.app import (
     TaskRequest,
     TaskResponse,
     TaskResponseVerbose,
+    TrajectoryQueryParams,
 )
 from futurehouse_client.models.rest import (
     ExecutionStatus,
+    UserAgentRequest,
+    UserAgentRequestPostPayload,
+    UserAgentRequestStatus,
+    UserAgentResponsePayload,
     WorldModel,
     WorldModelResponse,
 )
@@ -105,6 +111,22 @@ class JobCreationError(RestClientError):
     """Raised when there's an error creating a job."""
 
 
+class UserAgentRequestError(RestClientError):
+    """Base exception for User Agent Request operations."""
+
+
+class UserAgentRequestFetchError(UserAgentRequestError):
+    """Raised when there's an error fetching a user agent request."""
+
+
+class UserAgentRequestCreationError(UserAgentRequestError):
+    """Raised when there's an error creating a user agent request."""
+
+
+class UserAgentRequestResponseError(UserAgentRequestError):
+    """Raised when there's an error responding to a user agent request."""
+
+
 class WorldModelFetchError(RestClientError):
     """Raised when there's an error fetching a world model."""
 
@@ -535,6 +557,52 @@ class RestClient:
             return verbose_response
         return JobNames.get_response_object_from_job(verbose_response.job_name)(**data)
 
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    def cancel_task(self, task_id: str | None = None) -> bool:
+        """Cancel a specific task/trajectory."""
+        task_id = task_id or self.trajectory_id
+        url = f"/v0.1/trajectories/{task_id}/cancel"
+        full_url = f"{self.base_url}{url}"
+
+        with external_trace(
+            url=full_url,
+            method="POST",
+            library="httpx",
+            custom_params={
+                "operation": "cancel_job",
+                "job_id": task_id,
+            },
+        ):
+            get_task_response = self.get_task(task_id)
+            # cancel if task is in progress
+            if get_task_response.status == ExecutionStatus.IN_PROGRESS.value:
+                response = self.client.post(url)
+                try:
+                    response.raise_for_status()
+
+                except HTTPStatusError as e:
+                    if e.response.status_code in {
+                        HTTPStatus.UNAUTHORIZED,
+                        HTTPStatus.FORBIDDEN,
+                    }:
+                        raise PermissionError(
+                            f"Error canceling task: Permission denied for task {task_id}"
+                        ) from e
+                    if e.response.status_code == HTTPStatus.NOT_FOUND:
+                        raise TaskFetchError(
+                            f"Error canceling task: Trajectory not found for task {task_id}"
+                        ) from e
+                    raise
+
+                get_task_response = self.get_task(task_id)
+                return get_task_response.status == ExecutionStatus.CANCELLED.value
+        return False
+
     @retry(
         stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
         wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
@@ -927,6 +995,13 @@ class RestClient:
                     if config.task_queues_config
                     else None
                 ),
+                "user_input_config": (
+                    json.dumps([
+                        entity.model_dump() for entity in config.user_input_config
+                    ])
+                    if config.user_input_config
+                    else None
+                ),
             }
             response = self.multipart_client.post(
                 "/v0.1/builds",
@@ -1787,6 +1862,470 @@ class RestClient:
         except Exception as e:
             raise ProjectError(f"Error adding trajectory to project: {e}") from e
 
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    def get_tasks(
+        self,
+        query_params: TrajectoryQueryParams | None = None,
+        *,
+        project_id: UUID | None = None,
+        name: str | None = None,
+        user: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+        sort_by: str = "created_at",
+        sort_order: str = "desc",
+    ) -> list[dict[str, Any]]:
+        """Fetches trajectories with applied filtering.
+
+        Args:
+            query_params: Optional TrajectoryQueryParams model with all parameters
+            project_id: Optional project ID to filter trajectories by
+            name: Optional name filter for trajectories
+            user: Optional user email filter for trajectories
+            limit: Maximum number of trajectories to return (default: 50, max: 200)
+            offset: Number of trajectories to skip for pagination (default: 0)
+            sort_by: Field to sort by, either "created_at" or "name" (default: "created_at")
+            sort_order: Sort order, either "asc" or "desc" (default: "desc")
+
+        Returns:
+            List of trajectory dictionaries
+
+        Raises:
+            TaskFetchError: If there's an error fetching trajectories
+        """
+        try:
+            if query_params is not None:
+                params = query_params.to_query_params()
+            else:
+                params_model = TrajectoryQueryParams(
+                    project_id=project_id,
+                    name=name,
+                    user=user,
+                    limit=limit,
+                    offset=offset,
+                    sort_by=sort_by,
+                    sort_order=sort_order,
+                )
+                params = params_model.to_query_params()
+
+            response = self.client.get("/v0.1/trajectories", params=params)
+            response.raise_for_status()
+            return response.json()
+        except HTTPStatusError as e:
+            if e.response.status_code in {401, 403}:
+                raise PermissionError(
+                    "Error getting trajectories: Permission denied"
+                ) from e
+            raise TaskFetchError(
+                f"Error getting trajectories: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise TaskFetchError(f"Error getting trajectories: {e!r}") from e
+
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    async def aget_tasks(
+        self,
+        query_params: TrajectoryQueryParams | None = None,
+        *,
+        project_id: UUID | None = None,
+        name: str | None = None,
+        user: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+        sort_by: str = "created_at",
+        sort_order: str = "desc",
+    ) -> list[dict[str, Any]]:
+        """Asynchronously fetch trajectories with applied filtering.
+
+        Args:
+            query_params: Optional TrajectoryQueryParams model with all parameters
+            project_id: Optional project ID to filter trajectories by
+            name: Optional name filter for trajectories
+            user: Optional user email filter for trajectories
+            limit: Maximum number of trajectories to return (default: 50, max: 200)
+            offset: Number of trajectories to skip for pagination (default: 0)
+            sort_by: Field to sort by, either "created_at" or "name" (default: "created_at")
+            sort_order: Sort order, either "asc" or "desc" (default: "desc")
+
+        Returns:
+            List of trajectory dictionaries
+
+        Raises:
+            TaskFetchError: If there's an error fetching trajectories
+        """
+        try:
+            if query_params is not None:
+                params = query_params.to_query_params()
+            else:
+                params_model = TrajectoryQueryParams(
+                    project_id=project_id,
+                    name=name,
+                    user=user,
+                    limit=limit,
+                    offset=offset,
+                    sort_by=sort_by,
+                    sort_order=sort_order,
+                )
+                params = params_model.to_query_params()
+
+            response = await self.async_client.get("/v0.1/trajectories", params=params)
+            response.raise_for_status()
+            return response.json()
+        except HTTPStatusError as e:
+            if e.response.status_code in {401, 403}:
+                raise PermissionError(
+                    "Error getting trajectories: Permission denied"
+                ) from e
+            raise TaskFetchError(
+                f"Error getting trajectories: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise TaskFetchError(f"Error getting trajectories: {e!r}") from e
+
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    def list_user_agent_requests(
+        self,
+        user_id: str | None = None,
+        trajectory_id: UUID | None = None,
+        request_status: UserAgentRequestStatus | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> list[UserAgentRequest]:
+        """List user agent requests with optional filters.
+
+        Args:
+            user_id: Filter requests by user ID. Defaults to the authenticated user's ID if not provided.
+            trajectory_id: Filter requests by trajectory ID.
+            request_status: Filter requests by status (e.g., PENDING).
+            limit: Maximum number of requests to return.
+            offset: Offset for pagination.
+
+        Returns:
+            A list of user agent requests.
+
+        Raises:
+            UserAgentRequestFetchError: If the API call fails.
+        """
+        params = {
+            "user_id": user_id,
+            "trajectory_id": str(trajectory_id) if trajectory_id else None,
+            "request_status": request_status.value if request_status else None,
+            "limit": limit,
+            "offset": offset,
+        }
+        # Filter out None values
+        params = {k: v for k, v in params.items() if v is not None}
+        try:
+            response = self.client.get("/v0.1/user-agent-requests", params=params)
+            response.raise_for_status()
+            return [UserAgentRequest.model_validate(item) for item in response.json()]
+        except HTTPStatusError as e:
+            raise UserAgentRequestFetchError(
+                f"Error listing user agent requests: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise UserAgentRequestFetchError(
+                f"An unexpected error occurred: {e!r}"
+            ) from e
+
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    async def alist_user_agent_requests(
+        self,
+        user_id: str | None = None,
+        trajectory_id: UUID | None = None,
+        request_status: UserAgentRequestStatus | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> list[UserAgentRequest]:
+        """Asynchronously list user agent requests with optional filters.
+
+        Args:
+            user_id: Filter requests by user ID. Defaults to the authenticated user's ID if not provided.
+            trajectory_id: Filter requests by trajectory ID.
+            request_status: Filter requests by status (e.g., PENDING).
+            limit: Maximum number of requests to return.
+            offset: Offset for pagination.
+
+        Returns:
+            A list of user agent requests.
+
+        Raises:
+            UserAgentRequestFetchError: If the API call fails.
+        """
+        params = {
+            "user_id": user_id,
+            "trajectory_id": str(trajectory_id) if trajectory_id else None,
+            "request_status": request_status.value if request_status else None,
+            "limit": limit,
+            "offset": offset,
+        }
+        # Filter out None values
+        params = {k: v for k, v in params.items() if v is not None}
+        try:
+            response = await self.async_client.get(
+                "/v0.1/user-agent-requests", params=params
+            )
+            response.raise_for_status()
+            return [UserAgentRequest.model_validate(item) for item in response.json()]
+        except HTTPStatusError as e:
+            raise UserAgentRequestFetchError(
+                f"Error listing user agent requests: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise UserAgentRequestFetchError(
+                f"An unexpected error occurred: {e!r}"
+            ) from e
+
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    def get_user_agent_request(self, request_id: UUID) -> UserAgentRequest:
+        """Retrieve a single user agent request by its unique ID.
+
+        Args:
+            request_id: The unique ID of the request.
+
+        Returns:
+            The user agent request.
+
+        Raises:
+            UserAgentRequestFetchError: If the API call fails or the request is not found.
+        """
+        try:
+            response = self.client.get(f"/v0.1/user-agent-requests/{request_id}")
+            response.raise_for_status()
+            return UserAgentRequest.model_validate(response.json())
+        except HTTPStatusError as e:
+            if e.response.status_code == codes.NOT_FOUND:
+                raise UserAgentRequestFetchError(
+                    f"User agent request with ID {request_id} not found."
+                ) from e
+            raise UserAgentRequestFetchError(
+                f"Error fetching user agent request: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise UserAgentRequestFetchError(
+                f"An unexpected error occurred: {e!r}"
+            ) from e
+
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    async def aget_user_agent_request(self, request_id: UUID) -> UserAgentRequest:
+        """Asynchronously retrieve a single user agent request by its unique ID.
+
+        Args:
+            request_id: The unique ID of the request.
+
+        Returns:
+            The user agent request.
+
+        Raises:
+            UserAgentRequestFetchError: If the API call fails or the request is not found.
+        """
+        try:
+            response = await self.async_client.get(
+                f"/v0.1/user-agent-requests/{request_id}"
+            )
+            response.raise_for_status()
+            return UserAgentRequest.model_validate(response.json())
+        except HTTPStatusError as e:
+            if e.response.status_code == codes.NOT_FOUND:
+                raise UserAgentRequestFetchError(
+                    f"User agent request with ID {request_id} not found."
+                ) from e
+            raise UserAgentRequestFetchError(
+                f"Error fetching user agent request: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise UserAgentRequestFetchError(
+                f"An unexpected error occurred: {e!r}"
+            ) from e
+
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    def create_user_agent_request(self, payload: UserAgentRequestPostPayload) -> UUID:
+        """Creates a new request from an agent to a user.
+
+        Args:
+            payload: An instance of UserAgentRequestPostPayload with the request data.
+
+        Returns:
+            The UUID of the newly created user agent request.
+
+        Raises:
+            UserAgentRequestCreationError: If the API call fails.
+        """
+        try:
+            response = self.client.post(
+                "/v0.1/user-agent-requests", json=payload.model_dump(mode="json")
+            )
+            response.raise_for_status()
+            return UUID(response.json())
+        except HTTPStatusError as e:
+            if e.response.status_code == codes.UNPROCESSABLE_ENTITY:
+                raise UserAgentRequestCreationError(
+                    f"Invalid payload for user agent request creation: {e.response.text}."
+                ) from e
+            raise UserAgentRequestCreationError(
+                f"Error creating user agent request: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise UserAgentRequestCreationError(
+                f"An unexpected error occurred during user agent request creation: {e!r}."
+            ) from e
+
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    async def acreate_user_agent_request(
+        self, payload: UserAgentRequestPostPayload
+    ) -> UUID:
+        """Asynchronously creates a new request from an agent to a user.
+
+        Args:
+            payload: An instance of UserAgentRequestPostPayload with the request data.
+
+        Returns:
+            The UUID of the newly created user agent request.
+
+        Raises:
+            UserAgentRequestCreationError: If the API call fails.
+        """
+        try:
+            response = await self.async_client.post(
+                "/v0.1/user-agent-requests", json=payload.model_dump(mode="json")
+            )
+            response.raise_for_status()
+            return UUID(response.json())
+        except HTTPStatusError as e:
+            if e.response.status_code == codes.UNPROCESSABLE_ENTITY:
+                raise UserAgentRequestCreationError(
+                    f"Invalid payload for user agent request creation: {e.response.text}."
+                ) from e
+            raise UserAgentRequestCreationError(
+                f"Error creating user agent request: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise UserAgentRequestCreationError(
+                f"An unexpected error occurred during user agent request creation: {e!r}."
+            ) from e
+
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    def respond_to_user_agent_request(
+        self, request_id: UUID, payload: UserAgentResponsePayload
+    ) -> None:
+        """Submit a user's response to a pending agent request.
+
+        Args:
+            request_id: The unique ID of the request to respond to.
+            payload: An instance of UserAgentResponsePayload with the response data.
+
+        Raises:
+            UserAgentRequestResponseError: If the API call fails.
+        """
+        try:
+            response = self.client.post(
+                f"/v0.1/user-agent-requests/{request_id}/response",
+                json=payload.model_dump(mode="json"),
+            )
+            response.raise_for_status()
+        except HTTPStatusError as e:
+            if e.response.status_code == codes.NOT_FOUND:
+                raise UserAgentRequestResponseError(
+                    f"User agent request with ID {request_id} not found."
+                ) from e
+            if e.response.status_code == codes.UNPROCESSABLE_ENTITY:
+                raise UserAgentRequestResponseError(
+                    f"Invalid response payload: {e.response.text}."
+                ) from e
+            raise UserAgentRequestResponseError(
+                f"Error responding to user agent request: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise UserAgentRequestResponseError(
+                f"An unexpected error occurred while responding to the request: {e!r}."
+            ) from e
+
+    @retry(
+        stop=stop_after_attempt(MAX_RETRY_ATTEMPTS),
+        wait=wait_exponential(multiplier=RETRY_MULTIPLIER, max=MAX_RETRY_WAIT),
+        retry=retry_if_connection_error,
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+    async def arespond_to_user_agent_request(
+        self, request_id: UUID, payload: UserAgentResponsePayload
+    ) -> None:
+        """Asynchronously submit a user's response to a pending agent request.
+
+        Args:
+            request_id: The unique ID of the request to respond to.
+            payload: An instance of UserAgentResponsePayload with the response data.
+
+        Raises:
+            UserAgentRequestResponseError: If the API call fails.
+        """
+        try:
+            response = await self.async_client.post(
+                f"/v0.1/user-agent-requests/{request_id}/response",
+                json=payload.model_dump(mode="json"),
+            )
+            response.raise_for_status()
+        except HTTPStatusError as e:
+            if e.response.status_code == codes.NOT_FOUND:
+                raise UserAgentRequestResponseError(
+                    f"User agent request with ID {request_id} not found."
+                ) from e
+            if e.response.status_code == codes.UNPROCESSABLE_ENTITY:
+                raise UserAgentRequestResponseError(
+                    f"Invalid response payload: {e.response.text}."
+                ) from e
+            raise UserAgentRequestResponseError(
+                f"Error responding to user agent request: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except Exception as e:
+            raise UserAgentRequestResponseError(
+                f"An unexpected error occurred while responding to the request: {e!r}."
+            ) from e
+
 
 def get_installed_packages() -> dict[str, str]:
     """Returns a dictionary of installed packages and their versions."""

futurehouse_client/models/app.py

@@ -278,6 +278,20 @@ class FramePath(BaseModel):
     )
 
 
+class NamedEntity(BaseModel):
+    name: str = Field(
+        description=(
+            "Name of an entity for a user to provide a value to during query submission. "
+            "This will be used as a key to prompt users for a value. "
+            "Example: 'pdb' would result in <pdb>user input here</pdb> in the task string."
+        )
+    )
+    description: str | None = Field(
+        default=None,
+        description="Helper text to provide the user context to what the name or format needs to be.",
+    )
+
+
 class DockerContainerConfiguration(BaseModel):
     cpu: str = Field(description="CPU allotment for the container")
     memory: str = Field(description="Memory allotment for the container")
@@ -458,6 +472,15 @@ class JobDeploymentConfig(BaseModel):
         description="The configuration for the task queue(s) that will be created for this deployment.",
     )
 
+    user_input_config: list[NamedEntity] | None = Field(
+        default=None,
+        description=(
+            "List of NamedEntity objects that represent user input fields "
+            "to be included in the task string. "
+            "These will be used to prompt users for values during query submission."
+        ),
+    )
+
     @field_validator("markdown_template_path")
     @classmethod
     def validate_markdown_path(
@@ -646,6 +669,62 @@ class RuntimeConfig(BaseModel):
         return value
 
 
+class TrajectoryQueryParams(BaseModel):
+    """Params for trajectories with filtering."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    project_id: UUID | None = Field(
+        default=None, description="Optional project ID to filter trajectories by"
+    )
+    name: str | None = Field(
+        default=None, description="Optional name filter for trajectories"
+    )
+    user: str | None = Field(
+        default=None, description="Optional user email filter for trajectories"
+    )
+    limit: int = Field(
+        default=50,
+        ge=1,
+        le=200,
+        description="Maximum number of trajectories to return (max: 200)",
+    )
+    offset: int = Field(
+        default=0, ge=0, description="Number of trajectories to skip for pagination"
+    )
+    sort_by: str = Field(default="created_at", description="Field to sort by")
+    sort_order: str = Field(default="desc", description="Sort order")
+
+    @field_validator("sort_by")
+    @classmethod
+    def validate_sort_by(cls, v: str) -> str:
+        if v not in {"created_at", "name"}:
+            raise ValueError("sort_by must be either 'created_at' or 'name'")
+        return v
+
+    @field_validator("sort_order")
+    @classmethod
+    def validate_sort_order(cls, v: str) -> str:
+        if v not in {"asc", "desc"}:
+            raise ValueError("sort_order must be either 'asc' or 'desc'")
+        return v
+
+    def to_query_params(self) -> dict[str, str | int]:
+        params: dict[str, str | int] = {
+            "limit": self.limit,
+            "offset": self.offset,
+            "sort_by": self.sort_by,
+            "sort_order": self.sort_order,
+        }
+        if self.project_id is not None:
+            params["project_id"] = str(self.project_id)
+        if self.name is not None:
+            params["name"] = self.name
+        if self.user is not None:
+            params["user"] = self.user
+        return params
+
+
 class TaskRequest(BaseModel):
     model_config = ConfigDict(extra="forbid")
 

futurehouse_client/models/client.py

@@ -27,13 +27,17 @@ class InitialState(BaseState):
 
 class ASVState(BaseState, Generic[T]):
     action: OpResult[T] = Field()
-    next_agent_state: Any = Field()
+    next_state: Any = Field()
     value: float = Field()
 
     @field_serializer("action")
     def serialize_action(self, action: OpResult[T]) -> dict:
         return action.to_dict()
 
+    @field_serializer("next_state")
+    def serialize_next_state(self, state: Any) -> str:
+        return str(state)
+
 
 class EnvResetState(BaseState):
     observations: list[Message] = Field()

futurehouse_client/models/rest.py

@@ -2,7 +2,7 @@ from datetime import datetime
 from enum import StrEnum, auto
 from uuid import UUID
 
-from pydantic import BaseModel, JsonValue
+from pydantic import BaseModel, ConfigDict, JsonValue
 
 
 class FinalEnvironmentRequest(BaseModel):
@@ -70,3 +70,50 @@ class WorldModelResponse(BaseModel):
     model_metadata: JsonValue | None
     enabled: bool
     created_at: datetime
+
+
+class UserAgentRequestStatus(StrEnum):
+    """Enum for the status of a user agent request."""
+
+    PENDING = auto()
+    RESPONDED = auto()
+    EXPIRED = auto()
+    CANCELLED = auto()
+
+
+class UserAgentRequest(BaseModel):
+    """Sister model for UserAgentRequestsDB."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    id: UUID
+    user_id: str
+    trajectory_id: UUID
+    response_trajectory_id: UUID | None = None
+    request: JsonValue
+    response: JsonValue | None = None
+    request_world_model_edit_id: UUID | None = None
+    response_world_model_edit_id: UUID | None = None
+    expires_at: datetime | None = None
+    user_response_task: JsonValue | None = None
+    status: UserAgentRequestStatus
+    created_at: datetime | None = None
+    modified_at: datetime | None = None
+
+
+class UserAgentRequestPostPayload(BaseModel):
+    """Payload to create a new user agent request."""
+
+    trajectory_id: UUID
+    request: JsonValue
+    request_world_model_edit_id: UUID | None = None
+    status: UserAgentRequestStatus = UserAgentRequestStatus.PENDING
+    expires_in_seconds: int | None = None
+    user_response_task: JsonValue | None = None
+
+
+class UserAgentResponsePayload(BaseModel):
+    """Payload for a user to submit a response to a request."""
+
+    response: JsonValue
+    response_world_model_edit_id: UUID | None = None

futurehouse_client/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.20.dev225'
-__version_tuple__ = version_tuple = (0, 3, 20, 'dev225')
+__version__ = version = '0.3.20.dev266'
+__version_tuple__ = version_tuple = (0, 3, 20, 'dev266')

{futurehouse_client-0.3.20.dev225.dist-info → futurehouse_client-0.3.20.dev266.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: futurehouse-client
-Version: 0.3.20.dev225
+Version: 0.3.20.dev266
 Summary: A client for interacting with endpoints of the FutureHouse service.
 Author-email: FutureHouse technical staff <hello@futurehouse.org>
 License:                                  Apache License

{futurehouse_client-0.3.20.dev225.dist-info → futurehouse_client-0.3.20.dev266.dist-info}/RECORD

@@ -1,20 +1,20 @@
 futurehouse_client/__init__.py,sha256=BztM_ntbgmIEjzvnBWcvPhvLjM8xGDFCK0Upf3-nIn8,488
 futurehouse_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-futurehouse_client/version.py,sha256=UzQXVtwR5aOM-s9sEJYt5xEHWLIMFYPuR7s_I_I9-sI,530
+futurehouse_client/version.py,sha256=BuvmuyFVBsO4OXG69bB2-CE0nYFKK5whAaQhu308ukU,530
 futurehouse_client/clients/__init__.py,sha256=-HXNj-XJ3LRO5XM6MZ709iPs29YpApss0Q2YYg1qMZw,280
 futurehouse_client/clients/job_client.py,sha256=D51_qTxya6g5Wfg_ZfJdP031TV_YDJeXkGMiYAJ1qRc,11962
-futurehouse_client/clients/rest_client.py,sha256=m4izsMCwq2V_oR-zkzxdLE-4y6Z0mm5ArWvpvtuaBKY,70158
+futurehouse_client/clients/rest_client.py,sha256=L8U3Ap-91_A90PkC00n-WwhVkK9oQjgxR59JAykyhjw,91929
 futurehouse_client/models/__init__.py,sha256=kQ4R7VEuRxO0IQEW_sk9CndBL7zzl8rUKI24ddyYLM0,647
-futurehouse_client/models/app.py,sha256=SvkXOu5Qx28_jCS84XKKepnpGyfrQUEVnxS-JGqmsaE,29128
-futurehouse_client/models/client.py,sha256=WFD1ddR0O7nD1ErqcJ-kt_miIW22KP6IDOSkaSdVZ8M,1716
-futurehouse_client/models/rest.py,sha256=AwPMcB1ruoqaI8NIhX2ZzN8UuX6XsaQ7uzeSE8EpwKk,1573
+futurehouse_client/models/app.py,sha256=TGoAeENNPc5mSBkMHjh-Z8VIlnaUNcoWUJLxUhRIkEE,31868
+futurehouse_client/models/client.py,sha256=n4HD0KStKLm6Ek9nL9ylP-bkK10yzAaD1uIDF83Qp_A,1828
+futurehouse_client/models/rest.py,sha256=LDHs6dINdbiwHlLBBP1RFd43PgP7mCAAnSAr7-l_2Mw,2924
 futurehouse_client/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 futurehouse_client/utils/auth.py,sha256=tgWELjKfg8eWme_qdcRmc8TjQN9DVZuHHaVXZNHLchk,2960
 futurehouse_client/utils/general.py,sha256=A_rtTiYW30ELGEZlWCIArO7q1nEmqi8hUlmBRYkMQ_c,767
 futurehouse_client/utils/module_utils.py,sha256=aFyd-X-pDARXz9GWpn8SSViUVYdSbuy9vSkrzcVIaGI,4955
 futurehouse_client/utils/monitoring.py,sha256=UjRlufe67kI3VxRHOd5fLtJmlCbVA2Wqwpd4uZhXkQM,8728
-futurehouse_client-0.3.20.dev225.dist-info/licenses/LICENSE,sha256=oQ9ZHjUi-_6GfP3gs14FlPb0OlGwE1QCCKFGnJ4LD2I,11341
-futurehouse_client-0.3.20.dev225.dist-info/METADATA,sha256=Ns45fN-WRg5MFzEERIfrHHHIsSB-cLXIVMyPY3a-R1c,26805
-futurehouse_client-0.3.20.dev225.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-futurehouse_client-0.3.20.dev225.dist-info/top_level.txt,sha256=TRuLUCt_qBnggdFHCX4O_BoCu1j2X43lKfIZC-ElwWY,19
-futurehouse_client-0.3.20.dev225.dist-info/RECORD,,
+futurehouse_client-0.3.20.dev266.dist-info/licenses/LICENSE,sha256=oQ9ZHjUi-_6GfP3gs14FlPb0OlGwE1QCCKFGnJ4LD2I,11341
+futurehouse_client-0.3.20.dev266.dist-info/METADATA,sha256=qJo9JB9L8Myv_ErPaEdr4e96gJx3JNPIYbbg8MZ7Qoc,26805
+futurehouse_client-0.3.20.dev266.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+futurehouse_client-0.3.20.dev266.dist-info/top_level.txt,sha256=TRuLUCt_qBnggdFHCX4O_BoCu1j2X43lKfIZC-ElwWY,19
+futurehouse_client-0.3.20.dev266.dist-info/RECORD,,