universal-mcp 0.1.9rc1__py3-none-any.whl → 0.1.10__py3-none-any.whl

universal_mcp/applications/replicate/app.py

@@ -37,17 +37,17 @@ class ReplicateApp(APIApplication):
     def account_get(self) -> dict[str, Any]:
         """
         Gets information about the authenticated account.
-        
+
         Args:
             None: This function takes no parameters.
-        
+
         Returns:
             Dict[str, Any]: A dictionary containing account details including type, username, name, and other account-related information.
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
             RequestException: When there are network connectivity issues or other request-related problems
-        
+
         Tags:
             account, get, read, api, authentication, important
         """
@@ -61,16 +61,16 @@ class ReplicateApp(APIApplication):
     def collections_list(self) -> dict[str, Any]:
         """
         Lists collections of models available on Replicate, returning a paginated list of collection objects.
-        
+
         Args:
             None: This function takes no arguments other than self
-        
+
         Returns:
             A dictionary containing a paginated list of collection objects from the Replicate API
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
-        
+
         Tags:
             list, collections, read, api, important, fetch, models
         """
@@ -80,76 +80,81 @@ class ReplicateApp(APIApplication):
         return response.json()
 
     def collections_get(self, collection_slug: str) -> dict[str, Any]:
-            """
-            Retrieves detailed information about a specific model collection, with automatic truncation of large model lists to manage response size.
-            
-            Args:
-                collection_slug: The unique identifier (slug) for the collection to retrieve (e.g., 'super-resolution')
-            
-            Returns:
-                A dictionary containing collection details and its associated models. If the model list exceeds the truncation threshold (15), returns a modified dictionary with the model list replaced by a summary count and message.
-            
-            Raises:
-                HTTPError: Raised when the API request fails or returns an error status code
-                RequestException: Raised when there's a network-related error during the API request
-            
-            Tags:
-                get, read, collections, api, data-retrieval, important, truncation
-            """
-            url = f"{self.base_url}/collections/{collection_slug}"
-            response = self._get(url)
-            response.raise_for_status()
-            collection_data = response.json()
-            if 'models' in collection_data and isinstance(collection_data['models'], list):
-                original_model_count = len(collection_data['models'])
-
-                # Define a threshold for truncation.
-                # This is a heuristic value. You might need to adjust this number
-                # based on how many model objects typically fit within your LLM's context,
-                # considering the size of each model object description.
-                TRUNCATION_THRESHOLD = 10 # Example: Truncate if more than 15 models
-
-                if original_model_count > TRUNCATION_THRESHOLD:
-                    logger.warning(f"Truncating model list for collection '{collection_slug}'. Found {original_model_count} models, exceeding threshold {TRUNCATION_THRESHOLD}.")
-
-                    # Create a new dictionary with essential collection data
-                    # and replace the 'models' list with a summary.
-                    truncated_data = {
-                        k: v for k, v in collection_data.items()
-                        if k != 'models' # Exclude the full models list
-                    }
-                    # Add information about the models list being truncated
-                    truncated_data['model_count'] = original_model_count
-                    truncated_data['models'] = f"List of {original_model_count} models omitted due to size. Use models_get for details on individual models by owner/name."
-                    # Optionally, include a small number of models as a preview, but this adds size.
-                    # For maximum reduction, just provide the count and message.
-                    # truncated_data['models_preview'] = collection_data['models'][:5] # Example: include first 5 models
-
-                    return truncated_data
-                else:
-                    # If the list is not too large, return the full data
-                    return collection_data
+        """
+        Retrieves detailed information about a specific model collection, with automatic truncation of large model lists to manage response size.
+
+        Args:
+            collection_slug: The unique identifier (slug) for the collection to retrieve (e.g., 'super-resolution')
+
+        Returns:
+            A dictionary containing collection details and its associated models. If the model list exceeds the truncation threshold (15), returns a modified dictionary with the model list replaced by a summary count and message.
+
+        Raises:
+            HTTPError: Raised when the API request fails or returns an error status code
+            RequestException: Raised when there's a network-related error during the API request
+
+        Tags:
+            get, read, collections, api, data-retrieval, important, truncation
+        """
+        url = f"{self.base_url}/collections/{collection_slug}"
+        response = self._get(url)
+        response.raise_for_status()
+        collection_data = response.json()
+        if "models" in collection_data and isinstance(collection_data["models"], list):
+            original_model_count = len(collection_data["models"])
+
+            # Define a threshold for truncation.
+            # This is a heuristic value. You might need to adjust this number
+            # based on how many model objects typically fit within your LLM's context,
+            # considering the size of each model object description.
+            TRUNCATION_THRESHOLD = 10  # Example: Truncate if more than 15 models
+
+            if original_model_count > TRUNCATION_THRESHOLD:
+                logger.warning(
+                    f"Truncating model list for collection '{collection_slug}'. Found {original_model_count} models, exceeding threshold {TRUNCATION_THRESHOLD}."
+                )
+
+                # Create a new dictionary with essential collection data
+                # and replace the 'models' list with a summary.
+                truncated_data = {
+                    k: v
+                    for k, v in collection_data.items()
+                    if k != "models"  # Exclude the full models list
+                }
+                # Add information about the models list being truncated
+                truncated_data["model_count"] = original_model_count
+                truncated_data["models"] = (
+                    f"List of {original_model_count} models omitted due to size. Use models_get for details on individual models by owner/name."
+                )
+                # Optionally, include a small number of models as a preview, but this adds size.
+                # For maximum reduction, just provide the count and message.
+                # truncated_data['models_preview'] = collection_data['models'][:5] # Example: include first 5 models
+
+                return truncated_data
             else:
-                # If 'models' key is missing or not a list, return the data as is
-                # (This handles cases where the structure is unexpected, or an error occurred before this point)
+                # If the list is not too large, return the full data
                 return collection_data
+        else:
+            # If 'models' key is missing or not a list, return the data as is
+            # (This handles cases where the structure is unexpected, or an error occurred before this point)
+            return collection_data
 
     # --- Deployment Operations ---
 
     def deployments_list(self) -> dict[str, Any]:
         """
         Lists all deployments associated with the authenticated account.
-        
+
         Args:
             None: This function takes no arguments.
-        
+
         Returns:
             Dict[str, Any]: A dictionary containing a paginated list of deployment objects with deployment details and metadata.
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
             RequestException: When there are network connectivity issues or API communication errors
-        
+
         Tags:
             list, read, deployments, api, management, important
         """
@@ -169,7 +174,7 @@ class ReplicateApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Creates a new model deployment with specified configuration parameters.
-        
+
         Args:
             name: The name of the deployment
             model: The full name of the model (e.g., 'stability-ai/sdxl')
@@ -177,13 +182,13 @@ class ReplicateApp(APIApplication):
             hardware: The SKU for the hardware (e.g., 'gpu-t4')
             min_instances: The minimum number of instances, ranging from 0 to 5
             max_instances: The maximum number of instances, ranging from 0 to 20
-        
+
         Returns:
             Dictionary containing the details of the newly created deployment
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
-        
+
         Tags:
             create, deployment, configuration, api, infrastructure, scaling, important
         """
@@ -200,20 +205,22 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def deployments_get(self, deployment_owner: str, deployment_name: str) -> dict[str, Any]:
+    def deployments_get(
+        self, deployment_owner: str, deployment_name: str
+    ) -> dict[str, Any]:
         """
         Retrieves detailed information about a specific deployment by its owner and name.
-        
+
         Args:
             deployment_owner: The owner's username or organization name associated with the deployment
             deployment_name: The unique name identifier of the deployment
-        
+
         Returns:
             A dictionary containing detailed information about the requested deployment
-        
+
         Raises:
             HTTPError: When the HTTP request fails or returns a non-200 status code
-        
+
         Tags:
             get, read, deployments, api, fetch, important
         """
@@ -233,7 +240,7 @@ class ReplicateApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Updates configurable properties of an existing deployment, such as hardware specifications and instance scaling parameters.
-        
+
         Args:
             deployment_owner: The owner's username or organization name
             deployment_name: The name of the deployment to be updated
@@ -241,13 +248,13 @@ class ReplicateApp(APIApplication):
             max_instances: Optional. The new maximum number of instances for scaling
             min_instances: Optional. The new minimum number of instances for scaling
             version: Optional. The new ID of the model version to deploy
-        
+
         Returns:
             Dictionary containing the updated deployment configuration details or a message if no updates were provided
-        
+
         Raises:
             HTTPError: Raised when the API request fails or returns an error status code
-        
+
         Tags:
             update, deployments, configuration, scaling, management, important
         """
@@ -260,7 +267,7 @@ class ReplicateApp(APIApplication):
         }
         update_data = {k: v for k, v in update_data.items() if v is not None}
         if not update_data:
-             return {"message": "No update parameters provided."}
+            return {"message": "No update parameters provided."}
         response = self._patch(url, data=update_data)
         response.raise_for_status()
         return response.json()
@@ -268,25 +275,24 @@ class ReplicateApp(APIApplication):
     def deployments_delete(self, deployment_owner: str, deployment_name: str) -> str:
         """
         Deletes a specified deployment associated with a given owner or organization
-        
+
         Args:
             deployment_owner: The username or organization name that owns the deployment
             deployment_name: The unique identifier/name of the deployment to be deleted
-        
+
         Returns:
             A string containing a success message confirming the deployment deletion
-        
+
         Raises:
             HTTPError: If the deletion request fails due to server error, invalid permissions, deployment being in use, or deployment not found
-        
+
         Tags:
             delete, deployments, management, important, infrastructure, resource-management
         """
         url = f"{self.base_url}/deployments/{deployment_owner}/{deployment_name}"
         response = self._delete(url)
         response.raise_for_status()
-        return f"Deployment '{deployment_owner}/{deployment_name}' deleted successfully." # Assuming 204 No Content
-
+        return f"Deployment '{deployment_owner}/{deployment_name}' deleted successfully."  # Assuming 204 No Content
 
     # --- Deployments Predictions Operations ---
     # Note: The 'Prefer: wait' header is not directly supported by default _post.
@@ -297,13 +303,15 @@ class ReplicateApp(APIApplication):
         deployment_owner: str,
         deployment_name: str,
         input: dict[str, Any],
-        stream: bool = None, # Deprecated according to schema
+        stream: bool = None,  # Deprecated according to schema
         webhook: str = None,
-        webhook_events_filter: list[Literal["start", "output", "logs", "completed"]] = None,
+        webhook_events_filter: list[
+            Literal["start", "output", "logs", "completed"]
+        ] = None,
     ) -> dict[str, Any]:
         """
         Creates an asynchronous prediction using a specified deployment, optionally configuring webhook notifications for status updates.
-        
+
         Args:
             deployment_owner: The owner's username or organization name of the deployment
             deployment_name: The name of the deployment to use for prediction
@@ -311,21 +319,21 @@ class ReplicateApp(APIApplication):
             stream: Deprecated parameter for requesting streaming output URL
             webhook: HTTPS URL where prediction status updates will be sent
             webhook_events_filter: List of specific events to trigger webhook notifications ('start', 'output', 'logs', 'completed')
-        
+
         Returns:
             Dictionary containing the initial prediction state, including a prediction ID for status polling
-        
+
         Raises:
             HTTPError: When the API request fails or returns an error status code
             JSONDecodeError: When the API response contains invalid JSON
-        
+
         Tags:
             create, predict, async, deployments, webhook, http-request, important
         """
         url = f"{self.base_url}/deployments/{deployment_owner}/{deployment_name}/predictions"
         request_body = {
             "input": input,
-            "stream": stream, # Included for completeness, though deprecated
+            "stream": stream,  # Included for completeness, though deprecated
             "webhook": webhook,
             "webhook_events_filter": webhook_events_filter,
         }
@@ -334,19 +342,18 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-
     # --- Hardware Operations ---
 
     def hardware_list(self) -> list[dict[str, Any]]:
         """
         Retrieves a list of available hardware options for running models.
-        
+
         Returns:
             List[Dict[str, Any]]: A list of dictionaries, where each dictionary represents a hardware option containing 'name' and 'sku' keys.
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
-        
+
         Tags:
             list, hardware, read, api, configuration, important
         """
@@ -355,20 +362,19 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-
     # --- Model Operations ---
 
     def models_list(self) -> dict[str, Any]:
         """
         Retrieves a paginated list of publicly available models from the Replicate API.
-        
+
         Returns:
             Dict[str, Any]: A dictionary containing the paginated list of model objects with their metadata and configurations.
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
             RequestException: When there are network connectivity issues or other request-related problems
-        
+
         Tags:
             list, models, read, api, fetch, important
         """
@@ -391,7 +397,7 @@ class ReplicateApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Creates a new model in the system with specified parameters and metadata.
-        
+
         Args:
             owner: The username or organization name that will own the model
             name: The name of the model (must be unique for the owner)
@@ -402,13 +408,13 @@ class ReplicateApp(APIApplication):
             github_url: Optional URL for the model's source code repository
             license_url: Optional URL for the model's license documentation
             paper_url: Optional URL for the associated research paper
-        
+
         Returns:
             Dictionary containing the details and metadata of the newly created model
-        
+
         Raises:
             HTTPError: Raised when the API request fails or returns an error status code
-        
+
         Tags:
             create, models, management, api, important
         """
@@ -432,17 +438,17 @@ class ReplicateApp(APIApplication):
     def models_search(self, query: str) -> dict[str, Any]:
         """
         Searches for public models based on a provided query string
-        
+
         Args:
             query: A string containing the search query to filter models
-        
+
         Returns:
             A dictionary containing paginated search results with matching model objects
-        
+
         Raises:
             Exception: When the HTTP request fails or encounters network/server errors
             HTTPStatusError: When the API returns a non-successful status code
-        
+
         Tags:
             search, models, query, read, api, http, important
         """
@@ -457,24 +463,23 @@ class ReplicateApp(APIApplication):
             response.raise_for_status()
             return response.json()
         except Exception as e:
-             logger.error(f"Error during models_search: {e}")
-             raise
-
+            logger.error(f"Error during models_search: {e}")
+            raise
 
     def models_get(self, model_owner: str, model_name: str) -> dict[str, Any]:
         """
         Retrieves detailed information about a specific AI model by its owner and name
-        
+
         Args:
             model_owner: The owner's username or organization name who owns the model
             model_name: The unique name identifier of the model
-        
+
         Returns:
             A dictionary containing detailed model information, including its latest version and usage examples
-        
+
         Raises:
             HTTPError: Raised when the API request fails, such as when the model doesn't exist or there are authentication issues
-        
+
         Tags:
             get, read, models, api, metadata, important
         """
@@ -486,43 +491,42 @@ class ReplicateApp(APIApplication):
     def models_delete(self, model_owner: str, model_name: str) -> str:
         """
         Deletes a private model from the system, provided it has no existing versions.
-        
+
         Args:
             model_owner: The owner's username or organization name of the model
             model_name: The name of the model to be deleted
-        
+
         Returns:
             A success message string confirming the model deletion
-        
+
         Raises:
             HTTPError: When deletion fails due to model being public, having existing versions, or other API restrictions
-        
+
         Tags:
             delete, models, management, important, api, cleanup
         """
         url = f"{self.base_url}/models/{model_owner}/{model_name}"
         response = self._delete(url)
-        response.raise_for_status() # Expecting 204 No Content
+        response.raise_for_status()  # Expecting 204 No Content
         return f"Model '{model_owner}/{model_name}' deleted successfully."
 
-
     # --- Model Examples Operations ---
 
     def models_examples_list(self, model_owner: str, model_name: str) -> dict[str, Any]:
         """
         Retrieves a list of example predictions associated with a specific model.
-        
+
         Args:
             model_owner: The owner's username or organization name of the model
             model_name: The name of the model to retrieve examples for
-        
+
         Returns:
             A dictionary containing a paginated list of example prediction objects for the specified model
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
             RequestException: When there are network connectivity issues or API communication errors
-        
+
         Tags:
             list, read, models, examples, api, pagination, prediction
         """
@@ -531,9 +535,8 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-
     # --- Model Predictions Operations ---
-     # Note: The 'Prefer: wait' header is not directly supported by default _post.
+    # Note: The 'Prefer: wait' header is not directly supported by default _post.
     # The response will likely be 201 or 202, requiring polling via predictions_get.
 
     def models_predictions_create(
@@ -541,13 +544,15 @@ class ReplicateApp(APIApplication):
         model_owner: str,
         model_name: str,
         input: dict[str, Any],
-        stream: bool = None, # Deprecated according to schema
+        stream: bool = None,  # Deprecated according to schema
         webhook: str = None,
-        webhook_events_filter: list[Literal["start", "output", "logs", "completed"]] = None,
+        webhook_events_filter: list[
+            Literal["start", "output", "logs", "completed"]
+        ] = None,
     ) -> dict[str, Any]:
         """
         Creates an asynchronous prediction request using a specified machine learning model.
-        
+
         Args:
             model_owner: The owner's username or organization name
             model_name: The name of the model to use for prediction
@@ -555,20 +560,20 @@ class ReplicateApp(APIApplication):
             stream: DEPRECATED. Boolean flag to request a streaming output URL
             webhook: HTTPS URL for receiving prediction status updates and results
             webhook_events_filter: List of events to trigger webhook notifications ('start', 'output', 'logs', 'completed')
-        
+
         Returns:
             Dictionary containing the initial prediction state and metadata. Includes prediction ID for status polling.
-        
+
         Raises:
             HTTPError: Raised when the API request fails or returns an error status code
-        
+
         Tags:
             predict, create, async, models, webhook, api, ml, important
         """
         url = f"{self.base_url}/models/{model_owner}/{model_name}/predictions"
         request_body = {
             "input": input,
-            "stream": stream, # Included for completeness, though deprecated
+            "stream": stream,  # Included for completeness, though deprecated
             "webhook": webhook,
             "webhook_events_filter": webhook_events_filter,
         }
@@ -577,49 +582,47 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-
     # --- Model Readme Operations ---
 
     def models_readme_get(self, model_owner: str, model_name: str) -> str:
         """
         Retrieves the README content for a specified model in Markdown format.
-        
+
         Args:
             model_owner: The owner's username or organization name
             model_name: The name of the model
-        
+
         Returns:
             A string containing the README content in Markdown format
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
             RequestException: When there are network connectivity issues or other request-related problems
-        
+
         Tags:
             get, read, models, documentation, markdown, api, metadata
         """
         url = f"{self.base_url}/models/{model_owner}/{model_name}/readme"
         response = self._get(url)
         response.raise_for_status()
-        return response.text # README is text/plain
-
+        return response.text  # README is text/plain
 
     # --- Model Versions Operations ---
 
     def models_versions_list(self, model_owner: str, model_name: str) -> dict[str, Any]:
         """
         Lists all available versions of a specified model.
-        
+
         Args:
             model_owner: The username or organization name that owns the model
             model_name: The name of the model whose versions are to be listed
-        
+
         Returns:
             A dictionary containing a paginated list of model version objects with version details
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
-        
+
         Tags:
             list, read, models, versions, api, management, paginated, important
         """
@@ -628,21 +631,23 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def models_versions_get(self, model_owner: str, model_name: str, version_id: str) -> dict[str, Any]:
+    def models_versions_get(
+        self, model_owner: str, model_name: str, version_id: str
+    ) -> dict[str, Any]:
         """
         Retrieves detailed information about a specific version of a model by querying the API.
-        
+
         Args:
             model_owner: The owner's username or organization name who owns the model
             model_name: The name of the model to query
             version_id: The unique identifier of the specific model version
-        
+
         Returns:
             A dictionary containing detailed information about the model version, including its OpenAPI schema and metadata
-        
+
         Raises:
             HTTPError: Raised when the API request fails, such as when the model version doesn't exist or there are authentication issues
-        
+
         Tags:
             get, read, models, versions, api, metadata, important
         """
@@ -651,30 +656,31 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def models_versions_delete(self, model_owner: str, model_name: str, version_id: str) -> str:
+    def models_versions_delete(
+        self, model_owner: str, model_name: str, version_id: str
+    ) -> str:
         """
         Deletes a specific version of a model and its associated predictions/output.
-        
+
         Args:
             model_owner: The owner's username or organization name
             model_name: The name of the model
             version_id: The ID of the version to be deleted
-        
+
         Returns:
             A success message confirming the deletion request was accepted
-        
+
         Raises:
             HTTPError: If the deletion request fails due to API restrictions or permissions
-        
+
         Tags:
             delete, models, versions, management, important
         """
         url = f"{self.base_url}/models/{model_owner}/{model_name}/versions/{version_id}"
         response = self._delete(url)
-        response.raise_for_status() # Expecting 202 Accepted or 204 No Content
+        response.raise_for_status()  # Expecting 202 Accepted or 204 No Content
         return f"Deletion request for version '{version_id}' of model '{model_owner}/{model_name}' accepted."
 
-
     # --- Training Operations (via Model Version) ---
 
     def trainings_create(
@@ -685,11 +691,13 @@ class ReplicateApp(APIApplication):
         destination: str,
         input: dict[str, Any],
         webhook: str = None,
-        webhook_events_filter: list[Literal["start", "output", "logs", "completed"]] = None,
+        webhook_events_filter: list[
+            Literal["start", "output", "logs", "completed"]
+        ] = None,
     ) -> dict[str, Any]:
         """
         Initiates a new asynchronous training job for a specific model version, with optional webhook notifications for progress updates.
-        
+
         Args:
             model_owner: The owner's username or organization name of the base model
             model_name: The name of the base model
@@ -698,13 +706,13 @@ class ReplicateApp(APIApplication):
             input: Dictionary containing inputs for the training function
             webhook: Optional HTTPS URL for receiving training updates
             webhook_events_filter: Optional list of events to trigger webhooks ('start', 'output', 'logs', 'completed')
-        
+
         Returns:
             Dictionary containing the initial state of the training job
-        
+
         Raises:
             HTTPError: Raised when the API request fails or returns an error status code
-        
+
         Tags:
             training, create, async-job, start, model-management, webhook, important
         """
@@ -720,28 +728,27 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-
     # --- Prediction Operations ---
 
     def predictions_list(
         self,
-        created_after: str = None, # ISO 8601 date-time
-        created_before: str = None, # ISO 8601 date-time
+        created_after: str = None,  # ISO 8601 date-time
+        created_before: str = None,  # ISO 8601 date-time
     ) -> dict[str, Any]:
         """
         Lists all predictions created by the authenticated account within an optional time range.
-        
+
         Args:
             created_after: ISO 8601 date-time string specifying the lower bound for prediction creation time (inclusive)
             created_before: ISO 8601 date-time string specifying the upper bound for prediction creation time (exclusive)
-        
+
         Returns:
             Dictionary containing a paginated list of prediction objects with their associated metadata
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
             RequestException: When there are network connectivity issues or invalid request parameters
-        
+
         Tags:
             list, read, predictions, query, filter, pagination, important
         """
@@ -762,26 +769,28 @@ class ReplicateApp(APIApplication):
         self,
         version: str,
         input: dict[str, Any],
-        stream: bool = None, # Deprecated according to schema
+        stream: bool = None,  # Deprecated according to schema
         webhook: str = None,
-        webhook_events_filter: list[Literal["start", "output", "logs", "completed"]] = None,
+        webhook_events_filter: list[
+            Literal["start", "output", "logs", "completed"]
+        ] = None,
     ) -> dict[str, Any]:
         """
         Creates an asynchronous prediction request using a specified model version.
-        
+
         Args:
             version: The ID of the model version to execute the prediction
             input: A dictionary containing the input data for the model prediction
             stream: Deprecated parameter - Previously used for requesting streaming output URL
             webhook: Optional HTTPS URL to receive prediction status updates and results
             webhook_events_filter: Optional list of event types to trigger webhook notifications. Valid events: 'start', 'output', 'logs', 'completed'
-        
+
         Returns:
             A dictionary containing the initial prediction state, including a prediction ID for status tracking
-        
+
         Raises:
             HTTPError: Raised when the API request fails or returns an error status code
-        
+
         Tags:
             predictions, create, async, api, model, important, webhook, ml
         """
@@ -789,7 +798,7 @@ class ReplicateApp(APIApplication):
         request_body = {
             "version": version,
             "input": input,
-            "stream": stream, # Included for completeness, though deprecated
+            "stream": stream,  # Included for completeness, though deprecated
             "webhook": webhook,
             "webhook_events_filter": webhook_events_filter,
         }
@@ -798,21 +807,20 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-
     def predictions_get(self, prediction_id: str) -> dict[str, Any]:
         """
         Retrieves the current state and details of a prediction by its ID.
-        
+
         Args:
             prediction_id: String identifier of the prediction to retrieve
-        
+
         Returns:
             Dictionary containing the prediction's current state and associated details
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
             RequestException: When there are network connectivity issues or invalid URL
-        
+
         Tags:
             get, read, status, predictions, retrieve, api, important
         """
@@ -821,26 +829,30 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def predictions_cancel(self, prediction_id: str) -> str: # Schema shows no content for 200 success
+    def predictions_cancel(
+        self, prediction_id: str
+    ) -> str:  # Schema shows no content for 200 success
         """
         Cancels a running prediction job identified by its ID.
-        
+
         Args:
             prediction_id: The unique identifier of the prediction job to cancel
-        
+
         Returns:
             A string message confirming successful cancellation of the prediction
-        
+
         Raises:
             HTTPError: When the API request fails or returns an error status code
             RequestException: When there are network connectivity issues or other request-related problems
-        
+
         Tags:
             cancel, predictions, management, api, async-job, important
         """
         url = f"{self.base_url}/predictions/{prediction_id}/cancel"
-        response = self._post(url, data={}) # POST with empty body for cancel according to typical patterns
-        response.raise_for_status() # Expecting 200 Success or similar
+        response = self._post(
+            url, data={}
+        )  # POST with empty body for cancel according to typical patterns
+        response.raise_for_status()  # Expecting 200 Success or similar
         return f"Prediction '{prediction_id}' cancelled successfully."
 
     # --- Training Operations ---
@@ -848,14 +860,14 @@ class ReplicateApp(APIApplication):
     def trainings_list(self) -> dict[str, Any]:
         """
         Lists all training jobs created by the authenticated account.
-        
+
         Returns:
             Dict[str, Any]: A dictionary containing a paginated list of training objects with their details and metadata.
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
             RequestException: When there's a network error or connection issue
-        
+
         Tags:
             list, read, trainings, management, important
         """
@@ -867,16 +879,16 @@ class ReplicateApp(APIApplication):
     def trainings_get(self, training_id: str) -> dict[str, Any]:
         """
         Retrieves the current state of a training job by its ID.
-        
+
         Args:
             training_id: A string identifier for the training job
-        
+
         Returns:
             A dictionary containing the current state and details of the training job
-        
+
         Raises:
             HTTPError: When the API request fails or returns a non-200 status code
-        
+
         Tags:
             get, read, status, training, api, fetch, monitor, important
         """
@@ -888,22 +900,22 @@ class ReplicateApp(APIApplication):
     def trainings_cancel(self, training_id: str) -> dict[str, Any]:
         """
         Cancels a specific training job in progress.
-        
+
         Args:
             training_id: String identifier of the training job to be cancelled
-        
+
         Returns:
             Dictionary containing the updated state and details of the cancelled training job
-        
+
         Raises:
             HTTPError: When the cancellation request fails or the server returns an error response
             RequestException: When network issues or connection problems occur during the API call
-        
+
         Tags:
             cancel, trainings, management, async-job, important
         """
         url = f"{self.base_url}/trainings/{training_id}/cancel"
-        response = self._post(url, data={}) # POST with empty body for cancel
+        response = self._post(url, data={})  # POST with empty body for cancel
         response.raise_for_status()
         return response.json()
 
@@ -912,14 +924,14 @@ class ReplicateApp(APIApplication):
     def webhooks_default_secret_get(self) -> dict[str, str]:
         """
         Retrieves the signing secret for the default webhook endpoint.
-        
+
         Returns:
             Dict[str, str]: A dictionary containing the 'key' field with the signing secret value.
-        
+
         Raises:
             HTTPError: If the API request fails or returns a non-200 status code.
             RequestException: If there are network connectivity issues or other request-related problems.
-        
+
         Tags:
             get, read, webhooks, security, secret, authentication, api, important
         """
@@ -928,7 +940,6 @@ class ReplicateApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-
     # --- Required list_tools method ---
 
     def list_tools(self):
@@ -957,7 +968,7 @@ class ReplicateApp(APIApplication):
             self.models_versions_list,
             self.models_versions_get,
             self.models_versions_delete,
-            self.trainings_create, # Training is started via model version path
+            self.trainings_create,  # Training is started via model version path
             self.predictions_list,
             self.predictions_create,
             self.predictions_get,
@@ -966,4 +977,4 @@ class ReplicateApp(APIApplication):
             self.trainings_get,
             self.trainings_cancel,
             self.webhooks_default_secret_get,
-        ]
+        ]