diff --git a/litellm/files/main.py b/litellm/files/main.py index a7c82290c29..e92a58b3f8c 100644 --- a/litellm/files/main.py +++ b/litellm/files/main.py @@ -8,6 +8,8 @@ https://platform.openai.com/docs/api-reference/files import asyncio import contextvars import os +import time +import uuid from functools import partial from typing import Any, Coroutine, Dict, Literal, Optional, Union, cast @@ -60,7 +62,7 @@ async def acreate_file( file: FileTypes, purpose: Literal["assistants", "batch", "fine-tune"], expires_after: Optional[FileExpiresAfter] = None, - custom_llm_provider: Literal["openai", "azure", "vertex_ai", "bedrock", "hosted_vllm"] = "openai", + custom_llm_provider: Literal["openai", "azure", "vertex_ai", "bedrock", "hosted_vllm", "manus"] = "openai", extra_headers: Optional[Dict[str, str]] = None, extra_body: Optional[Dict[str, str]] = None, **kwargs, @@ -105,7 +107,7 @@ def create_file( file: FileTypes, purpose: Literal["assistants", "batch", "fine-tune"], expires_after: Optional[FileExpiresAfter] = None, - custom_llm_provider: Optional[Literal["openai", "azure", "vertex_ai", "bedrock", "hosted_vllm"]] = None, + custom_llm_provider: Optional[Literal["openai", "azure", "vertex_ai", "bedrock", "hosted_vllm", "manus"]] = None, extra_headers: Optional[Dict[str, str]] = None, extra_body: Optional[Dict[str, str]] = None, **kwargs, @@ -274,7 +276,7 @@ def create_file( ) else: raise litellm.exceptions.BadRequestError( - message="LiteLLM doesn't support {} for 'create_file'. Only ['openai', 'azure', 'vertex_ai'] are supported.".format( + message="LiteLLM doesn't support {} for 'create_file'. Only ['openai', 'azure', 'vertex_ai', 'manus'] are supported.".format( custom_llm_provider ), model="n/a", @@ -293,7 +295,7 @@ def create_file( @client async def afile_retrieve( file_id: str, - custom_llm_provider: Literal["openai", "azure", "hosted_vllm"] = "openai", + custom_llm_provider: Literal["openai", "azure", "hosted_vllm", "manus"] = "openai", extra_headers: Optional[Dict[str, str]] = None, extra_body: Optional[Dict[str, str]] = None, **kwargs, @@ -334,7 +336,7 @@ async def afile_retrieve( @client def file_retrieve( file_id: str, - custom_llm_provider: Literal["openai", "azure", "hosted_vllm"] = "openai", + custom_llm_provider: Literal["openai", "azure", "hosted_vllm", "manus"] = "openai", extra_headers: Optional[Dict[str, str]] = None, extra_body: Optional[Dict[str, str]] = None, **kwargs, @@ -428,18 +430,60 @@ def file_retrieve( file_id=file_id, ) else: - raise litellm.exceptions.BadRequestError( - message="LiteLLM doesn't support {} for 'file_retrieve'. Only 'openai' and 'azure' are supported.".format( - custom_llm_provider - ), - model="n/a", - llm_provider=custom_llm_provider, - response=httpx.Response( - status_code=400, - content="Unsupported provider", - request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"), # type: ignore - ), + # Try using provider config pattern (for Manus, Bedrock, etc.) + provider_config = ProviderConfigManager.get_provider_files_config( + model="", + provider=LlmProviders(custom_llm_provider), ) + if provider_config is not None: + litellm_params_dict = get_litellm_params(**kwargs) + litellm_params_dict["api_key"] = optional_params.api_key + litellm_params_dict["api_base"] = optional_params.api_base + + logging_obj = kwargs.get("litellm_logging_obj") + if logging_obj is None: + from litellm.litellm_core_utils.litellm_logging import ( + Logging as LiteLLMLoggingObj, + ) + logging_obj = LiteLLMLoggingObj( + model="", + messages=[], + stream=False, + call_type="afile_retrieve" if _is_async else "file_retrieve", + start_time=time.time(), + litellm_call_id=kwargs.get("litellm_call_id", str(uuid.uuid4())), + function_id=str(kwargs.get("id") or ""), + ) + + client = kwargs.get("client") + response = base_llm_http_handler.retrieve_file( + file_id=file_id, + provider_config=provider_config, + litellm_params=litellm_params_dict, + headers=extra_headers or {}, + logging_obj=logging_obj, + _is_async=_is_async, + client=( + client + if client is not None + and isinstance(client, (HTTPHandler, AsyncHTTPHandler)) + else None + ), + timeout=timeout, + ) + else: + raise litellm.exceptions.BadRequestError( + message="LiteLLM doesn't support {} for 'file_retrieve'. Only 'openai', 'azure', and 'manus' are supported.".format( + custom_llm_provider + ), + model="n/a", + llm_provider=custom_llm_provider, + response=httpx.Response( + status_code=400, + content="Unsupported provider", + request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"), # type: ignore + ), + ) return cast(FileObject, response) except Exception as e: @@ -450,7 +494,7 @@ def file_retrieve( @client async def afile_delete( file_id: str, - custom_llm_provider: Literal["openai", "azure"] = "openai", + custom_llm_provider: Literal["openai", "azure", "manus"] = "openai", extra_headers: Optional[Dict[str, str]] = None, extra_body: Optional[Dict[str, str]] = None, **kwargs, @@ -494,7 +538,7 @@ async def afile_delete( def file_delete( file_id: str, model: Optional[str] = None, - custom_llm_provider: Union[Literal["openai", "azure"], str] = "openai", + custom_llm_provider: Union[Literal["openai", "azure", "manus"], str] = "openai", extra_headers: Optional[Dict[str, str]] = None, extra_body: Optional[Dict[str, str]] = None, **kwargs, @@ -596,18 +640,58 @@ def file_delete( litellm_params=litellm_params_dict, ) else: - raise litellm.exceptions.BadRequestError( - message="LiteLLM doesn't support {} for 'delete_batch'. Only 'openai' is supported.".format( - custom_llm_provider - ), - model="n/a", - llm_provider=custom_llm_provider, - response=httpx.Response( - status_code=400, - content="Unsupported provider", - request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"), # type: ignore - ), + # Try using provider config pattern (for Manus, Bedrock, etc.) + provider_config = ProviderConfigManager.get_provider_files_config( + model="", + provider=LlmProviders(custom_llm_provider), ) + if provider_config is not None: + litellm_params_dict["api_key"] = optional_params.api_key + litellm_params_dict["api_base"] = optional_params.api_base + + logging_obj = kwargs.get("litellm_logging_obj") + if logging_obj is None: + from litellm.litellm_core_utils.litellm_logging import ( + Logging as LiteLLMLoggingObj, + ) + logging_obj = LiteLLMLoggingObj( + model="", + messages=[], + stream=False, + call_type="afile_delete" if _is_async else "file_delete", + start_time=time.time(), + litellm_call_id=kwargs.get("litellm_call_id", str(uuid.uuid4())), + function_id=str(kwargs.get("id") or ""), + ) + + response = base_llm_http_handler.delete_file( + file_id=file_id, + provider_config=provider_config, + litellm_params=litellm_params_dict, + headers=extra_headers or {}, + logging_obj=logging_obj, + _is_async=_is_async, + client=( + client + if client is not None + and isinstance(client, (HTTPHandler, AsyncHTTPHandler)) + else None + ), + timeout=timeout, + ) + else: + raise litellm.exceptions.BadRequestError( + message="LiteLLM doesn't support {} for 'file_delete'. Only 'openai', 'azure', and 'manus' are supported.".format( + custom_llm_provider + ), + model="n/a", + llm_provider=custom_llm_provider, + response=httpx.Response( + status_code=400, + content="Unsupported provider", + request=httpx.Request(method="create_thread", url="https://github.com/BerriAI/litellm"), # type: ignore + ), + ) return cast(FileDeleted, response) except Exception as e: raise e @@ -616,7 +700,7 @@ def file_delete( # List files @client async def afile_list( - custom_llm_provider: Literal["openai", "azure"] = "openai", + custom_llm_provider: Literal["openai", "azure", "manus"] = "openai", purpose: Optional[str] = None, extra_headers: Optional[Dict[str, str]] = None, extra_body: Optional[Dict[str, str]] = None, @@ -657,7 +741,7 @@ async def afile_list( @client def file_list( - custom_llm_provider: Literal["openai", "azure"] = "openai", + custom_llm_provider: Literal["openai", "azure", "manus"] = "openai", purpose: Optional[str] = None, extra_headers: Optional[Dict[str, str]] = None, extra_body: Optional[Dict[str, str]] = None, @@ -687,7 +771,50 @@ def file_list( timeout = 600.0 _is_async = kwargs.pop("is_async", False) is True - if custom_llm_provider in OPENAI_COMPATIBLE_BATCH_AND_FILES_PROVIDERS: + + # Check if provider has a custom files config (e.g., Manus, Bedrock, Vertex AI) + provider_config = ProviderConfigManager.get_provider_files_config( + model="", + provider=LlmProviders(custom_llm_provider), + ) + if provider_config is not None: + litellm_params_dict = get_litellm_params(**kwargs) + litellm_params_dict["api_key"] = optional_params.api_key + litellm_params_dict["api_base"] = optional_params.api_base + + logging_obj = kwargs.get("litellm_logging_obj") + if logging_obj is None: + from litellm.litellm_core_utils.litellm_logging import ( + Logging as LiteLLMLoggingObj, + ) + logging_obj = LiteLLMLoggingObj( + model="", + messages=[], + stream=False, + call_type="afile_list" if _is_async else "file_list", + start_time=time.time(), + litellm_call_id=kwargs.get("litellm_call_id", str(uuid.uuid4())), + function_id=str(kwargs.get("id", "")), + ) + + client = kwargs.get("client") + response = base_llm_http_handler.list_files( + purpose=purpose, + provider_config=provider_config, + litellm_params=litellm_params_dict, + headers=extra_headers or {}, + logging_obj=logging_obj, + _is_async=_is_async, + client=( + client + if client is not None + and isinstance(client, (HTTPHandler, AsyncHTTPHandler)) + else None + ), + timeout=timeout, + ) + return response + elif custom_llm_provider in OPENAI_COMPATIBLE_BATCH_AND_FILES_PROVIDERS: # for deepinfra/perplexity/anyscale/groq we check in get_llm_provider and pass in the api base from there api_base = ( optional_params.api_base @@ -752,7 +879,7 @@ def file_list( ) else: raise litellm.exceptions.BadRequestError( - message="LiteLLM doesn't support {} for 'file_list'. Only 'openai' and 'azure' are supported.".format( + message="LiteLLM doesn't support {} for 'file_list'. Only 'openai', 'azure', and 'manus' are supported.".format( custom_llm_provider ), model="n/a", @@ -771,7 +898,7 @@ def file_list( @client async def afile_content( file_id: str, - custom_llm_provider: Literal["openai", "azure", "vertex_ai", "bedrock", "hosted_vllm", "anthropic"] = "openai", + custom_llm_provider: Literal["openai", "azure", "vertex_ai", "bedrock", "hosted_vllm", "anthropic", "manus"] = "openai", extra_headers: Optional[Dict[str, str]] = None, extra_body: Optional[Dict[str, str]] = None, **kwargs, @@ -816,7 +943,7 @@ def file_content( file_id: str, model: Optional[str] = None, custom_llm_provider: Optional[ - Union[Literal["openai", "azure", "vertex_ai", "bedrock", "hosted_vllm", "anthropic"], str] + Union[Literal["openai", "azure", "vertex_ai", "bedrock", "hosted_vllm", "anthropic", "manus"], str] ] = None, extra_headers: Optional[Dict[str, str]] = None, extra_body: Optional[Dict[str, str]] = None, @@ -977,7 +1104,7 @@ def file_content( ) else: raise litellm.exceptions.BadRequestError( - message="LiteLLM doesn't support {} for 'custom_llm_provider'. Supported providers are 'openai', 'azure', 'vertex_ai', 'bedrock'.".format( + message="LiteLLM doesn't support {} for 'file_content'. Supported providers are 'openai', 'azure', 'vertex_ai', 'bedrock', 'manus'.".format( custom_llm_provider ), model="n/a", diff --git a/litellm/llms/base_llm/files/transformation.py b/litellm/llms/base_llm/files/transformation.py index a21193e5fba..7b0a1868f19 100644 --- a/litellm/llms/base_llm/files/transformation.py +++ b/litellm/llms/base_llm/files/transformation.py @@ -2,12 +2,14 @@ from abc import ABC, abstractmethod from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union import httpx +from openai.types.file_deleted import FileDeleted from litellm.proxy._types import UserAPIKeyAuth from litellm.types.files import TwoStepFileUploadConfig from litellm.types.llms.openai import ( AllMessageValues, CreateFileRequest, + FileContentRequest, OpenAICreateFileRequestOptionalParams, OpenAIFileObject, OpenAIFilesPurpose, @@ -97,6 +99,86 @@ class BaseFilesConfig(BaseConfig): ) -> OpenAIFileObject: pass + @abstractmethod + def transform_retrieve_file_request( + self, + file_id: str, + optional_params: dict, + litellm_params: dict, + ) -> tuple[str, dict]: + """Transform file retrieve request into provider-specific format.""" + pass + + @abstractmethod + def transform_retrieve_file_response( + self, + raw_response: httpx.Response, + logging_obj: LiteLLMLoggingObj, + litellm_params: dict, + ) -> OpenAIFileObject: + """Transform file retrieve response into OpenAI format.""" + pass + + @abstractmethod + def transform_delete_file_request( + self, + file_id: str, + optional_params: dict, + litellm_params: dict, + ) -> tuple[str, dict]: + """Transform file delete request into provider-specific format.""" + pass + + @abstractmethod + def transform_delete_file_response( + self, + raw_response: httpx.Response, + logging_obj: LiteLLMLoggingObj, + litellm_params: dict, + ) -> "FileDeleted": + """Transform file delete response into OpenAI format.""" + pass + + @abstractmethod + def transform_list_files_request( + self, + purpose: Optional[str], + optional_params: dict, + litellm_params: dict, + ) -> tuple[str, dict]: + """Transform file list request into provider-specific format.""" + pass + + @abstractmethod + def transform_list_files_response( + self, + raw_response: httpx.Response, + logging_obj: LiteLLMLoggingObj, + litellm_params: dict, + ) -> List[OpenAIFileObject]: + """Transform file list response into OpenAI format.""" + pass + + @abstractmethod + def transform_file_content_request( + self, + file_content_request: "FileContentRequest", + optional_params: dict, + litellm_params: dict, + ) -> tuple[str, dict]: + """Transform file content request into provider-specific format.""" + pass + + @abstractmethod + def transform_file_content_response( + self, + raw_response: httpx.Response, + logging_obj: LiteLLMLoggingObj, + litellm_params: dict, + ) -> "HttpxBinaryResponseContent": + """Transform file content response into OpenAI format.""" + pass + def transform_request( self, model: str, diff --git a/litellm/llms/custom_httpx/llm_http_handler.py b/litellm/llms/custom_httpx/llm_http_handler.py index 13307e30ae4..9768e485f10 100644 --- a/litellm/llms/custom_httpx/llm_http_handler.py +++ b/litellm/llms/custom_httpx/llm_http_handler.py @@ -14,6 +14,7 @@ from typing import ( ) import httpx # type: ignore +from openai.types.file_deleted import FileDeleted import litellm import litellm.litellm_core_utils @@ -83,6 +84,7 @@ from litellm.types.llms.anthropic_skills import ( from litellm.types.llms.openai import ( CreateBatchRequest, CreateFileRequest, + FileContentRequest, HttpxBinaryResponseContent, OpenAIFileObject, ResponseInputParam, @@ -3789,29 +3791,525 @@ class BaseLLMHTTPHandler: logging_obj=logging_obj, ) - def list_files(self): + def retrieve_file( + self, + file_id: str, + provider_config: BaseFilesConfig, + litellm_params: dict, + headers: dict, + logging_obj: LiteLLMLoggingObj, + _is_async: bool = False, + client: Optional[Union[HTTPHandler, AsyncHTTPHandler]] = None, + timeout: Optional[Union[float, httpx.Timeout]] = None, + ) -> Union[OpenAIFileObject, Coroutine[Any, Any, OpenAIFileObject]]: """ - Lists all files + Retrieve file metadata by ID """ - pass + if _is_async: + return self.async_retrieve_file( + file_id=file_id, + provider_config=provider_config, + litellm_params=litellm_params, + headers=headers, + logging_obj=logging_obj, + client=client, + timeout=timeout, + ) - def delete_file(self): - """ - Deletes a file - """ - pass + if client is None or not isinstance(client, HTTPHandler): + sync_httpx_client = _get_httpx_client() + else: + sync_httpx_client = client - def retrieve_file(self): - """ - Returns the metadata of the file - """ - pass + # Get URL and params from provider config + url, params = provider_config.transform_retrieve_file_request( + file_id=file_id, + optional_params={}, + litellm_params=litellm_params, + ) - def retrieve_file_content(self): + # Validate environment and get headers + headers = provider_config.validate_environment( + api_key=litellm_params.get("api_key"), + headers=headers, + model="", + messages=[], + optional_params={}, + litellm_params=litellm_params, + ) + + logging_obj.pre_call( + input="", + api_key="", + additional_args={ + "api_base": url, + "headers": headers, + "file_id": file_id, + }, + ) + + try: + response = sync_httpx_client.get( + url=url, headers=headers, params=params + ) + except Exception as e: + raise self._handle_error(e=e, provider_config=provider_config) + + return provider_config.transform_retrieve_file_response( + raw_response=response, + logging_obj=logging_obj, + litellm_params=litellm_params, + ) + + async def async_retrieve_file( + self, + file_id: str, + provider_config: BaseFilesConfig, + litellm_params: dict, + headers: dict, + logging_obj: LiteLLMLoggingObj, + client: Optional[Union[HTTPHandler, AsyncHTTPHandler]] = None, + timeout: Optional[Union[float, httpx.Timeout]] = None, + ) -> OpenAIFileObject: """ - Returns the content of the file + Async retrieve file metadata by ID """ - pass + if client is None or not isinstance(client, AsyncHTTPHandler): + async_httpx_client = get_async_httpx_client( + llm_provider=provider_config.custom_llm_provider + ) + else: + async_httpx_client = client + + # Get URL and params from provider config + url, params = provider_config.transform_retrieve_file_request( + file_id=file_id, + optional_params={}, + litellm_params=litellm_params, + ) + + # Validate environment and get headers + headers = provider_config.validate_environment( + api_key=litellm_params.get("api_key"), + headers=headers, + model="", + messages=[], + optional_params={}, + litellm_params=litellm_params, + ) + + logging_obj.pre_call( + input="", + api_key="", + additional_args={ + "api_base": url, + "headers": headers, + "file_id": file_id, + }, + ) + + try: + response = await async_httpx_client.get( + url=url, headers=headers, params=params + ) + except Exception as e: + raise self._handle_error(e=e, provider_config=provider_config) + + return provider_config.transform_retrieve_file_response( + raw_response=response, + logging_obj=logging_obj, + litellm_params=litellm_params, + ) + + def delete_file( + self, + file_id: str, + provider_config: BaseFilesConfig, + litellm_params: dict, + headers: dict, + logging_obj: LiteLLMLoggingObj, + _is_async: bool = False, + client: Optional[Union[HTTPHandler, AsyncHTTPHandler]] = None, + timeout: Optional[Union[float, httpx.Timeout]] = None, + ) -> Union["FileDeleted", Coroutine[Any, Any, "FileDeleted"]]: + """ + Delete a file by ID + """ + if _is_async: + return self.async_delete_file( + file_id=file_id, + provider_config=provider_config, + litellm_params=litellm_params, + headers=headers, + logging_obj=logging_obj, + client=client, + timeout=timeout, + ) + + if client is None or not isinstance(client, HTTPHandler): + sync_httpx_client = _get_httpx_client() + else: + sync_httpx_client = client + + # Get URL and params from provider config + url, params = provider_config.transform_delete_file_request( + file_id=file_id, + optional_params={}, + litellm_params=litellm_params, + ) + + # Validate environment and get headers + headers = provider_config.validate_environment( + api_key=litellm_params.get("api_key"), + headers=headers, + model="", + messages=[], + optional_params={}, + litellm_params=litellm_params, + ) + + logging_obj.pre_call( + input="", + api_key="", + additional_args={ + "api_base": url, + "headers": headers, + "file_id": file_id, + }, + ) + + try: + response = sync_httpx_client.delete( + url=url, headers=headers, params=params + ) + except Exception as e: + raise self._handle_error(e=e, provider_config=provider_config) + + return provider_config.transform_delete_file_response( + raw_response=response, + logging_obj=logging_obj, + litellm_params=litellm_params, + ) + + async def async_delete_file( + self, + file_id: str, + provider_config: BaseFilesConfig, + litellm_params: dict, + headers: dict, + logging_obj: LiteLLMLoggingObj, + client: Optional[Union[HTTPHandler, AsyncHTTPHandler]] = None, + timeout: Optional[Union[float, httpx.Timeout]] = None, + ) -> "FileDeleted": + """ + Async delete a file by ID + """ + if client is None or not isinstance(client, AsyncHTTPHandler): + async_httpx_client = get_async_httpx_client( + llm_provider=provider_config.custom_llm_provider + ) + else: + async_httpx_client = client + + # Get URL and params from provider config + url, params = provider_config.transform_delete_file_request( + file_id=file_id, + optional_params={}, + litellm_params=litellm_params, + ) + + # Validate environment and get headers + headers = provider_config.validate_environment( + api_key=litellm_params.get("api_key"), + headers=headers, + model="", + messages=[], + optional_params={}, + litellm_params=litellm_params, + ) + + logging_obj.pre_call( + input="", + api_key="", + additional_args={ + "api_base": url, + "headers": headers, + "file_id": file_id, + }, + ) + + try: + response = await async_httpx_client.delete( + url=url, headers=headers, params=params, timeout=timeout + ) + except Exception as e: + raise self._handle_error(e=e, provider_config=provider_config) + + return provider_config.transform_delete_file_response( + raw_response=response, + logging_obj=logging_obj, + litellm_params=litellm_params, + ) + + def list_files( + self, + purpose: Optional[str], + provider_config: BaseFilesConfig, + litellm_params: dict, + headers: dict, + logging_obj: LiteLLMLoggingObj, + _is_async: bool = False, + client: Optional[Union[HTTPHandler, AsyncHTTPHandler]] = None, + timeout: Optional[Union[float, httpx.Timeout]] = None, + ) -> Union[List[OpenAIFileObject], Coroutine[Any, Any, List[OpenAIFileObject]]]: + """ + List all files + """ + if _is_async: + return self.async_list_files( + purpose=purpose, + provider_config=provider_config, + litellm_params=litellm_params, + headers=headers, + logging_obj=logging_obj, + client=client, + timeout=timeout, + ) + + if client is None or not isinstance(client, HTTPHandler): + sync_httpx_client = _get_httpx_client() + else: + sync_httpx_client = client + + # Get URL and params from provider config + url, params = provider_config.transform_list_files_request( + purpose=purpose, + optional_params={}, + litellm_params=litellm_params, + ) + + # Validate environment and get headers + headers = provider_config.validate_environment( + api_key=litellm_params.get("api_key"), + headers=headers, + model="", + messages=[], + optional_params={}, + litellm_params=litellm_params, + ) + + logging_obj.pre_call( + input="", + api_key="", + additional_args={ + "api_base": url, + "headers": headers, + "purpose": purpose, + }, + ) + + try: + response = sync_httpx_client.get( + url=url, headers=headers, params=params + ) + except Exception as e: + raise self._handle_error(e=e, provider_config=provider_config) + + return provider_config.transform_list_files_response( + raw_response=response, + logging_obj=logging_obj, + litellm_params=litellm_params, + ) + + async def async_list_files( + self, + purpose: Optional[str], + provider_config: BaseFilesConfig, + litellm_params: dict, + headers: dict, + logging_obj: LiteLLMLoggingObj, + client: Optional[Union[HTTPHandler, AsyncHTTPHandler]] = None, + timeout: Optional[Union[float, httpx.Timeout]] = None, + ) -> List[OpenAIFileObject]: + """ + Async list all files + """ + if client is None or not isinstance(client, AsyncHTTPHandler): + async_httpx_client = get_async_httpx_client( + llm_provider=provider_config.custom_llm_provider + ) + else: + async_httpx_client = client + + # Get URL and params from provider config + url, params = provider_config.transform_list_files_request( + purpose=purpose, + optional_params={}, + litellm_params=litellm_params, + ) + + # Validate environment and get headers + headers = provider_config.validate_environment( + api_key=litellm_params.get("api_key"), + headers=headers, + model="", + messages=[], + optional_params={}, + litellm_params=litellm_params, + ) + + logging_obj.pre_call( + input="", + api_key="", + additional_args={ + "api_base": url, + "headers": headers, + "purpose": purpose, + }, + ) + + try: + response = await async_httpx_client.get( + url=url, headers=headers, params=params + ) + except Exception as e: + raise self._handle_error(e=e, provider_config=provider_config) + + return provider_config.transform_list_files_response( + raw_response=response, + logging_obj=logging_obj, + litellm_params=litellm_params, + ) + + def retrieve_file_content( + self, + file_content_request: "FileContentRequest", + provider_config: BaseFilesConfig, + litellm_params: dict, + headers: dict, + logging_obj: LiteLLMLoggingObj, + _is_async: bool = False, + client: Optional[Union[HTTPHandler, AsyncHTTPHandler]] = None, + timeout: Optional[Union[float, httpx.Timeout]] = None, + ) -> Union["HttpxBinaryResponseContent", Coroutine[Any, Any, "HttpxBinaryResponseContent"]]: + """ + Retrieve file content by ID + """ + if _is_async: + return self.async_retrieve_file_content( + file_content_request=file_content_request, + provider_config=provider_config, + litellm_params=litellm_params, + headers=headers, + logging_obj=logging_obj, + client=client, + timeout=timeout, + ) + + if client is None or not isinstance(client, HTTPHandler): + sync_httpx_client = _get_httpx_client() + else: + sync_httpx_client = client + + # Get URL and params from provider config + url, params = provider_config.transform_file_content_request( + file_content_request=file_content_request, + optional_params={}, + litellm_params=litellm_params, + ) + + # Validate environment and get headers + headers = provider_config.validate_environment( + api_key=litellm_params.get("api_key"), + headers=headers, + model="", + messages=[], + optional_params={}, + litellm_params=litellm_params, + ) + + logging_obj.pre_call( + input="", + api_key="", + additional_args={ + "api_base": url, + "headers": headers, + "file_id": file_content_request.get("file_id"), + }, + ) + + try: + response = sync_httpx_client.get( + url=url, headers=headers, params=params + ) + except Exception as e: + raise self._handle_error(e=e, provider_config=provider_config) + + return provider_config.transform_file_content_response( + raw_response=response, + logging_obj=logging_obj, + litellm_params=litellm_params, + ) + + async def async_retrieve_file_content( + self, + file_content_request: "FileContentRequest", + provider_config: BaseFilesConfig, + litellm_params: dict, + headers: dict, + logging_obj: LiteLLMLoggingObj, + client: Optional[Union[HTTPHandler, AsyncHTTPHandler]] = None, + timeout: Optional[Union[float, httpx.Timeout]] = None, + ) -> "HttpxBinaryResponseContent": + """ + Async retrieve file content by ID + """ + if client is None or not isinstance(client, AsyncHTTPHandler): + async_httpx_client = get_async_httpx_client( + llm_provider=provider_config.custom_llm_provider + ) + else: + async_httpx_client = client + + # Get URL and params from provider config + url, params = provider_config.transform_file_content_request( + file_content_request=file_content_request, + optional_params={}, + litellm_params=litellm_params, + ) + + # Validate environment and get headers + headers = provider_config.validate_environment( + api_key=litellm_params.get("api_key"), + headers=headers, + model="", + messages=[], + optional_params={}, + litellm_params=litellm_params, + ) + + logging_obj.pre_call( + input="", + api_key="", + additional_args={ + "api_base": url, + "headers": headers, + "file_id": file_content_request.get("file_id"), + }, + ) + + try: + response = await async_httpx_client.get( + url=url, headers=headers, params=params + ) + except Exception as e: + raise self._handle_error(e=e, provider_config=provider_config) + + return provider_config.transform_file_content_response( + raw_response=response, + logging_obj=logging_obj, + litellm_params=litellm_params, + ) def _prepare_fake_stream_request( self, diff --git a/tests/llm_responses_api_testing/test_manus_files_all_methods.py b/tests/llm_responses_api_testing/test_manus_files_all_methods.py new file mode 100644 index 00000000000..39311441f59 --- /dev/null +++ b/tests/llm_responses_api_testing/test_manus_files_all_methods.py @@ -0,0 +1,71 @@ +""" +E2E test for all Manus Files API methods. +""" + +import os +import pytest +import litellm + + +@pytest.mark.asyncio +async def test_manus_files_api_e2e_all_methods(): + """ + E2E test for Manus Files API: create, retrieve, list, delete. + """ + litellm._turn_on_debug() + + api_key = os.getenv("MANUS_API_KEY") + if api_key is None: + pytest.skip("MANUS_API_KEY not set") + + # Create a simple test file content + test_content = b"This is a test file for Manus Files API - all methods test." + test_filename = "test_file_all_methods.txt" + + # Step 1: Create file + print("Step 1: Creating file...") + created_file = await litellm.acreate_file( + file=(test_filename, test_content), + purpose="assistants", + custom_llm_provider="manus", + api_key=api_key, + ) + print(f"Created file: {created_file}") + assert created_file.filename == test_filename + assert created_file.status == "uploaded" + # Note: Manus doesn't return bytes in initial response + file_id = created_file.id + + # Step 2: Retrieve file + print(f"\nStep 2: Retrieving file {file_id}...") + retrieved_file = await litellm.afile_retrieve( + file_id=file_id, + custom_llm_provider="manus", + api_key=api_key, + ) + print(f"Retrieved file: {retrieved_file}") + assert retrieved_file.id == file_id + assert retrieved_file.filename == test_filename + + # Step 3: List files + print("\nStep 3: Listing files...") + files_list = await litellm.afile_list( + custom_llm_provider="manus", + api_key=api_key, + ) + print(f"Files list: {files_list}") + assert isinstance(files_list, list) + assert any(f.id == file_id for f in files_list) + + # Step 4: Delete file + print(f"\nStep 4: Deleting file {file_id}...") + deleted_file = await litellm.afile_delete( + file_id=file_id, + custom_llm_provider="manus", + api_key=api_key, + ) + print(f"Deleted file: {deleted_file}") + assert deleted_file.id == file_id + assert deleted_file.deleted is True + + print("\n✅ All Manus Files API methods working!")