435 lines
14 KiB
Python
435 lines
14 KiB
Python
|
"""
|
||
|
|
Manus Files API implementation.
|
||
|
|
|
||
|
|
Manus has an OpenAI-compatible Files API with some differences:
|
||
|
|
- Uses API_KEY header instead of Authorization: Bearer
|
||
|
|
- File upload is a two-step process:
|
||
|
|
1. Create file record to get upload URL
|
||
|
|
2. Upload file content to the upload URL
|
||
|
|
|
||
|
|
Reference: https://open.manus.im/docs/openai-compatibility#file-management
|
||
|
|
"""
|
||
|
|
|
||
|
|
import time
|
||
|
|
from typing import Any, Dict, List, Optional, Union
|
||
|
|
|
||
|
|
import httpx
|
||
|
|
from openai.types.file_deleted import FileDeleted
|
||
|
|
|
||
|
|
import litellm
|
||
|
|
from litellm._logging import verbose_logger
|
||
|
|
from litellm.litellm_core_utils.prompt_templates.common_utils import extract_file_data
|
||
|
|
from litellm.llms.base_llm.chat.transformation import BaseLLMException
|
||
|
|
from litellm.llms.base_llm.files.transformation import (
|
||
|
|
BaseFilesConfig,
|
||
|
|
LiteLLMLoggingObj,
|
||
|
|
)
|
||
|
|
from litellm.llms.openai.common_utils import OpenAIError
|
||
|
|
from litellm.secret_managers.main import get_secret_str
|
||
|
|
from litellm.types.files import TwoStepFileUploadConfig, TwoStepFileUploadRequest
|
||
|
|
from litellm.types.llms.openai import (
|
||
|
|
CreateFileRequest,
|
||
|
|
FileContentRequest,
|
||
|
|
HttpxBinaryResponseContent,
|
||
|
|
OpenAICreateFileRequestOptionalParams,
|
||
|
|
OpenAIFileObject,
|
||
|
|
)
|
||
|
|
from litellm.types.utils import LlmProviders
|
||
|
|
|
||
|
|
MANUS_API_BASE = "https://api.manus.im"
|
||
|
|
|
||
|
|
|
||
|
|
class ManusFilesConfig(BaseFilesConfig):
|
||
|
|
"""
|
||
|
|
Configuration for Manus Files API.
|
||
|
|
|
||
|
|
Manus uses:
|
||
|
|
- API_KEY header for authentication (not Authorization: Bearer)
|
||
|
|
- Two-step file upload process
|
||
|
|
- Content-Type: application/json for all requests
|
||
|
|
|
||
|
|
Reference: https://open.manus.im/docs/openai-compatibility#file-management
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
@property
|
||
|
|
def custom_llm_provider(self) -> LlmProviders:
|
||
|
|
return LlmProviders.MANUS
|
||
|
|
|
||
|
|
def validate_environment(
|
||
|
|
self,
|
||
|
|
headers: dict,
|
||
|
|
model: str,
|
||
|
|
messages: list,
|
||
|
|
optional_params: dict,
|
||
|
|
litellm_params: dict,
|
||
|
|
api_key: Optional[str] = None,
|
||
|
|
api_base: Optional[str] = None,
|
||
|
|
) -> dict:
|
||
|
|
"""
|
||
|
|
Validate environment and set up headers for Manus API.
|
||
|
|
|
||
|
|
Manus uses API_KEY header instead of Authorization: Bearer.
|
||
|
|
For file uploads, don't set Content-Type - httpx will set it for multipart.
|
||
|
|
"""
|
||
|
|
api_key = api_key or litellm.api_key or get_secret_str("MANUS_API_KEY")
|
||
|
|
|
||
|
|
if not api_key:
|
||
|
|
raise ValueError(
|
||
|
|
"Manus API key is required. Set MANUS_API_KEY environment variable or pass api_key parameter."
|
||
|
|
)
|
||
|
|
|
||
|
|
# Manus uses API_KEY header, not Authorization: Bearer
|
||
|
|
# Manus requires Content-Type: application/json for all requests (even GET)
|
||
|
|
headers.update(
|
||
|
|
{
|
||
|
|
"API_KEY": api_key,
|
||
|
|
"Content-Type": "application/json",
|
||
|
|
}
|
||
|
|
)
|
||
|
|
return headers
|
||
|
|
|
||
|
|
def get_supported_openai_params(
|
||
|
|
self, model: str
|
||
|
|
) -> List[OpenAICreateFileRequestOptionalParams]:
|
||
|
|
"""
|
||
|
|
Return supported OpenAI file creation parameters for Manus.
|
||
|
|
Manus supports the standard 'purpose' parameter.
|
||
|
|
"""
|
||
|
|
return ["purpose"]
|
||
|
|
|
||
|
|
def map_openai_params(
|
||
|
|
self,
|
||
|
|
non_default_params: dict,
|
||
|
|
optional_params: dict,
|
||
|
|
model: str,
|
||
|
|
drop_params: bool,
|
||
|
|
) -> dict:
|
||
|
|
"""
|
||
|
|
Map OpenAI parameters to Manus-specific parameters.
|
||
|
|
Manus is OpenAI-compatible, so no special mapping needed.
|
||
|
|
"""
|
||
|
|
return optional_params
|
||
|
|
|
||
|
|
def get_complete_url(
|
||
|
|
self,
|
||
|
|
api_base: Optional[str],
|
||
|
|
api_key: Optional[str],
|
||
|
|
model: str,
|
||
|
|
optional_params: dict,
|
||
|
|
litellm_params: dict,
|
||
|
|
stream: Optional[bool] = None,
|
||
|
|
) -> str:
|
||
|
|
"""
|
||
|
|
Get the complete URL for Manus Files API endpoint.
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
str: The full URL for the Manus /v1/files endpoint
|
||
|
|
"""
|
||
|
|
api_base = (
|
||
|
|
api_base
|
||
|
|
or litellm.api_base
|
||
|
|
or get_secret_str("MANUS_API_BASE")
|
||
|
|
or MANUS_API_BASE
|
||
|
|
)
|
||
|
|
|
||
|
|
# Remove trailing slashes
|
||
|
|
api_base = api_base.rstrip("/")
|
||
|
|
|
||
|
|
# Manus API uses /v1/files endpoint
|
||
|
|
if api_base.endswith("/v1"):
|
||
|
|
return f"{api_base}/files"
|
||
|
|
return f"{api_base}/v1/files"
|
||
|
|
|
||
|
|
def get_error_class(
|
||
|
|
self,
|
||
|
|
error_message: str,
|
||
|
|
status_code: int,
|
||
|
|
headers: Union[dict, httpx.Headers],
|
||
|
|
) -> BaseLLMException:
|
||
|
|
"""
|
||
|
|
Return the appropriate error class for Manus API errors.
|
||
|
|
Uses OpenAIError since Manus is OpenAI-compatible.
|
||
|
|
"""
|
||
|
|
return OpenAIError(
|
||
|
|
status_code=status_code,
|
||
|
|
message=error_message,
|
||
|
|
headers=headers,
|
||
|
|
)
|
||
|
|
|
||
|
|
def transform_create_file_request(
|
||
|
|
self,
|
||
|
|
model: str,
|
||
|
|
create_file_data: CreateFileRequest,
|
||
|
|
optional_params: dict,
|
||
|
|
litellm_params: dict,
|
||
|
|
) -> TwoStepFileUploadConfig:
|
||
|
|
"""
|
||
|
|
Transform OpenAI-style file creation request into Manus's two-step format.
|
||
|
|
|
||
|
|
Manus API spec (https://open.manus.im/docs/openai-compatibility#file-management):
|
||
|
|
1. POST /v1/files with JSON {"filename": "..."} → returns {"id": "...", "upload_url": "..."}
|
||
|
|
2. PUT to upload_url with raw file content
|
||
|
|
"""
|
||
|
|
# Extract file data
|
||
|
|
file_data = create_file_data.get("file")
|
||
|
|
if file_data is None:
|
||
|
|
raise ValueError("File data is required")
|
||
|
|
|
||
|
|
extracted_data = extract_file_data(file_data)
|
||
|
|
filename = extracted_data["filename"] or f"file_{int(time.time())}"
|
||
|
|
content = extracted_data["content"]
|
||
|
|
|
||
|
|
# Get API base URL
|
||
|
|
api_base = self.get_complete_url(
|
||
|
|
api_base=litellm_params.get("api_base"),
|
||
|
|
api_key=litellm_params.get("api_key"),
|
||
|
|
model=model,
|
||
|
|
optional_params=optional_params,
|
||
|
|
litellm_params=litellm_params,
|
||
|
|
)
|
||
|
|
|
||
|
|
# Get API key
|
||
|
|
api_key = (
|
||
|
|
litellm_params.get("api_key")
|
||
|
|
or litellm.api_key
|
||
|
|
or get_secret_str("MANUS_API_KEY")
|
||
|
|
)
|
||
|
|
|
||
|
|
if not api_key:
|
||
|
|
raise ValueError(
|
||
|
|
"Manus API key is required. Set MANUS_API_KEY environment variable or pass api_key parameter."
|
||
|
|
)
|
||
|
|
|
||
|
|
# Build typed two-step upload config
|
||
|
|
return TwoStepFileUploadConfig(
|
||
|
|
initial_request=TwoStepFileUploadRequest(
|
||
|
|
method="POST",
|
||
|
|
url=api_base,
|
||
|
|
headers={
|
||
|
|
"API_KEY": api_key,
|
||
|
|
"Content-Type": "application/json",
|
||
|
|
},
|
||
|
|
data={"filename": filename},
|
||
|
|
),
|
||
|
|
upload_request=TwoStepFileUploadRequest(
|
||
|
|
method="PUT",
|
||
|
|
url="", # Will be populated from initial_request response
|
||
|
|
headers={},
|
||
|
|
data=content,
|
||
|
|
),
|
||
|
|
upload_url_location="body",
|
||
|
|
upload_url_key="upload_url",
|
||
|
|
)
|
||
|
|
|
||
|
|
def transform_create_file_response(
|
||
|
|
self,
|
||
|
|
model: Optional[str],
|
||
|
|
raw_response: httpx.Response,
|
||
|
|
logging_obj: LiteLLMLoggingObj,
|
||
|
|
litellm_params: dict,
|
||
|
|
) -> OpenAIFileObject:
|
||
|
|
"""
|
||
|
|
Transform Manus's file upload response into OpenAI-style FileObject.
|
||
|
|
|
||
|
|
For two-step uploads, the handler stores the initial response in litellm_params.
|
||
|
|
We need to return the file object from the initial POST, not the final PUT.
|
||
|
|
|
||
|
|
Manus initial response format:
|
||
|
|
{
|
||
|
|
"id": "file-abc123xyz",
|
||
|
|
"object": "file",
|
||
|
|
"filename": "document.pdf",
|
||
|
|
"status": "pending",
|
||
|
|
"upload_url": "https://...",
|
||
|
|
"upload_expires_at": "...",
|
||
|
|
"created_at": "..."
|
||
|
|
}
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
# For two-step uploads, get the initial response from litellm_params
|
||
|
|
initial_response_data = litellm_params.get("initial_file_response")
|
||
|
|
if initial_response_data:
|
||
|
|
response_json = initial_response_data
|
||
|
|
else:
|
||
|
|
# Log raw response for debugging
|
||
|
|
verbose_logger.debug(f"Manus raw response text: {raw_response.text}")
|
||
|
|
response_json = raw_response.json()
|
||
|
|
|
||
|
|
verbose_logger.debug(f"Manus file response: {response_json}")
|
||
|
|
|
||
|
|
# Parse created_at timestamp
|
||
|
|
created_at_str = response_json.get("created_at", "")
|
||
|
|
if created_at_str:
|
||
|
|
try:
|
||
|
|
# Try parsing ISO format
|
||
|
|
created_at = int(
|
||
|
|
time.mktime(
|
||
|
|
time.strptime(
|
||
|
|
created_at_str.replace("Z", "+00:00")[:19],
|
||
|
|
"%Y-%m-%dT%H:%M:%S",
|
||
|
|
)
|
||
|
|
)
|
||
|
|
)
|
||
|
|
except (ValueError, TypeError):
|
||
|
|
created_at = int(time.time())
|
||
|
|
else:
|
||
|
|
created_at = int(time.time())
|
||
|
|
|
||
|
|
return OpenAIFileObject(
|
||
|
|
id=response_json.get("id", ""),
|
||
|
|
bytes=response_json.get("bytes", 0),
|
||
|
|
created_at=created_at,
|
||
|
|
filename=response_json.get("filename", ""),
|
||
|
|
object="file",
|
||
|
|
purpose=response_json.get("purpose", "assistants"),
|
||
|
|
status="uploaded", # After successful upload, status is uploaded
|
||
|
|
status_details=response_json.get("status_details"),
|
||
|
|
)
|
||
|
|
except Exception as e:
|
||
|
|
verbose_logger.exception(f"Error parsing Manus file response: {str(e)}")
|
||
|
|
raise ValueError(f"Error parsing Manus file response: {str(e)}")
|
||
|
|
|
||
|
|
def transform_retrieve_file_request(
|
||
|
|
self,
|
||
|
|
file_id: str,
|
||
|
|
optional_params: dict,
|
||
|
|
litellm_params: dict,
|
||
|
|
) -> tuple[str, dict]:
|
||
|
|
"""Get URL and params for retrieving a file."""
|
||
|
|
api_base = self.get_complete_url(
|
||
|
|
api_base=litellm_params.get("api_base"),
|
||
|
|
api_key=litellm_params.get("api_key"),
|
||
|
|
model="",
|
||
|
|
optional_params=optional_params,
|
||
|
|
litellm_params=litellm_params,
|
||
|
|
)
|
||
|
|
return f"{api_base}/{file_id}", {}
|
||
|
|
|
||
|
|
def transform_retrieve_file_response(
|
||
|
|
self,
|
||
|
|
raw_response: httpx.Response,
|
||
|
|
logging_obj: LiteLLMLoggingObj,
|
||
|
|
litellm_params: dict,
|
||
|
|
) -> OpenAIFileObject:
|
||
|
|
"""Transform retrieve file response."""
|
||
|
|
return self.transform_create_file_response(
|
||
|
|
model=None,
|
||
|
|
raw_response=raw_response,
|
||
|
|
logging_obj=logging_obj,
|
||
|
|
litellm_params=litellm_params,
|
||
|
|
)
|
||
|
|
|
||
|
|
def transform_delete_file_request(
|
||
|
|
self,
|
||
|
|
file_id: str,
|
||
|
|
optional_params: dict,
|
||
|
|
litellm_params: dict,
|
||
|
|
) -> tuple[str, dict]:
|
||
|
|
"""Get URL and params for deleting a file."""
|
||
|
|
api_base = self.get_complete_url(
|
||
|
|
api_base=litellm_params.get("api_base"),
|
||
|
|
api_key=litellm_params.get("api_key"),
|
||
|
|
model="",
|
||
|
|
optional_params=optional_params,
|
||
|
|
litellm_params=litellm_params,
|
||
|
|
)
|
||
|
|
return f"{api_base}/{file_id}", {}
|
||
|
|
|
||
|
|
def transform_delete_file_response(
|
||
|
|
self,
|
||
|
|
raw_response: httpx.Response,
|
||
|
|
logging_obj: LiteLLMLoggingObj,
|
||
|
|
litellm_params: dict,
|
||
|
|
) -> FileDeleted:
|
||
|
|
"""Transform delete file response."""
|
||
|
|
response_json = raw_response.json()
|
||
|
|
return FileDeleted(**response_json)
|
||
|
|
|
||
|
|
def transform_list_files_request(
|
||
|
|
self,
|
||
|
|
purpose: Optional[str],
|
||
|
|
optional_params: dict,
|
||
|
|
litellm_params: dict,
|
||
|
|
) -> tuple[str, dict]:
|
||
|
|
"""Get URL and params for listing files."""
|
||
|
|
api_base = self.get_complete_url(
|
||
|
|
api_base=litellm_params.get("api_base"),
|
||
|
|
api_key=litellm_params.get("api_key"),
|
||
|
|
model="",
|
||
|
|
optional_params=optional_params,
|
||
|
|
litellm_params=litellm_params,
|
||
|
|
)
|
||
|
|
params = {}
|
||
|
|
if purpose:
|
||
|
|
params["purpose"] = purpose
|
||
|
|
return api_base, params
|
||
|
|
|
||
|
|
def transform_list_files_response(
|
||
|
|
self,
|
||
|
|
raw_response: httpx.Response,
|
||
|
|
logging_obj: LiteLLMLoggingObj,
|
||
|
|
litellm_params: dict,
|
||
|
|
) -> List[OpenAIFileObject]:
|
||
|
|
"""Transform list files response."""
|
||
|
|
response_json = raw_response.json()
|
||
|
|
files_data = response_json.get("data", [])
|
||
|
|
return [self._parse_file_dict(f) for f in files_data]
|
||
|
|
|
||
|
|
def _parse_file_dict(self, file_dict: Dict[str, Any]) -> OpenAIFileObject:
|
||
|
|
"""Parse a file dict into OpenAIFileObject."""
|
||
|
|
created_at_str = file_dict.get("created_at", "")
|
||
|
|
if created_at_str:
|
||
|
|
try:
|
||
|
|
created_at = int(
|
||
|
|
time.mktime(
|
||
|
|
time.strptime(
|
||
|
|
created_at_str.replace("Z", "+00:00")[:19],
|
||
|
|
"%Y-%m-%dT%H:%M:%S",
|
||
|
|
)
|
||
|
|
)
|
||
|
|
)
|
||
|
|
except (ValueError, TypeError):
|
||
|
|
created_at = int(time.time())
|
||
|
|
else:
|
||
|
|
created_at = int(time.time())
|
||
|
|
|
||
|
|
return OpenAIFileObject(
|
||
|
|
id=file_dict.get("id", ""),
|
||
|
|
bytes=file_dict.get("bytes", 0),
|
||
|
|
created_at=created_at,
|
||
|
|
filename=file_dict.get("filename", ""),
|
||
|
|
object="file",
|
||
|
|
purpose=file_dict.get("purpose", "assistants"),
|
||
|
|
status=file_dict.get("status", "uploaded"),
|
||
|
|
status_details=file_dict.get("status_details"),
|
||
|
|
)
|
||
|
|
|
||
|
|
def transform_file_content_request(
|
||
|
|
self,
|
||
|
|
file_content_request: FileContentRequest,
|
||
|
|
optional_params: dict,
|
||
|
|
litellm_params: dict,
|
||
|
|
) -> tuple[str, dict]:
|
||
|
|
"""Get URL and params for retrieving file content."""
|
||
|
|
file_id = file_content_request.get("file_id")
|
||
|
|
api_base = self.get_complete_url(
|
||
|
|
api_base=litellm_params.get("api_base"),
|
||
|
|
api_key=litellm_params.get("api_key"),
|
||
|
|
model="",
|
||
|
|
optional_params=optional_params,
|
||
|
|
litellm_params=litellm_params,
|
||
|
|
)
|
||
|
|
return f"{api_base}/{file_id}/content", {}
|
||
|
|
|
||
|
|
def transform_file_content_response(
|
||
|
|
self,
|
||
|
|
raw_response: httpx.Response,
|
||
|
|
logging_obj: LiteLLMLoggingObj,
|
||
|
|
litellm_params: dict,
|
||
|
|
) -> HttpxBinaryResponseContent:
|
||
|
|
"""Transform file content response."""
|
||
|
|
return HttpxBinaryResponseContent(response=raw_response)
|