Added GET and DELETE for OpenAI Responses API

litellm/llms/openai/responses/transformation.py

@@ -281,6 +281,7 @@ def transform_get_response_api_response(
         """
         try:
             raw_response_json = raw_response.json()
+            raw_response.raise_for_status()
         except Exception:
             raise OpenAIError(
                 message=raw_response.text, status_code=raw_response.status_code

litellm/proxy/common_request_processing.py

@@ -108,7 +108,7 @@ async def common_processing_pre_call_logic(
         user_api_key_dict: UserAPIKeyAuth,
         proxy_logging_obj: ProxyLogging,
         proxy_config: ProxyConfig,
-        route_type: Literal["acompletion", "aresponses", "_arealtime"],
+        route_type: Literal["acompletion", "aresponses", "aget_responses", "adelete_responses", "_arealtime"],
         version: Optional[str] = None,
         user_model: Optional[str] = None,
         user_temperature: Optional[float] = None,
@@ -178,7 +178,7 @@ async def base_process_llm_request(
         request: Request,
         fastapi_response: Response,
         user_api_key_dict: UserAPIKeyAuth,
-        route_type: Literal["acompletion", "aresponses", "_arealtime"],
+        route_type: Literal["acompletion", "aresponses", "aget_responses", "adelete_responses", "_arealtime"],
         proxy_logging_obj: ProxyLogging,
         general_settings: dict,
         proxy_config: ProxyConfig,

litellm/proxy/response_api_endpoints/endpoints.py

@@ -107,7 +107,52 @@ async def get_response(
     ```
     """
     # TODO: Implement response retrieval logic
-    pass
+    from litellm.proxy.proxy_server import (
+        _read_request_body,
+        general_settings,
+        llm_router,
+        proxy_config,
+        proxy_logging_obj,
+        select_data_generator,
+        user_api_base,
+        user_max_tokens,
+        user_model,
+        user_request_timeout,
+        user_temperature,
+        version,
+    )
+
+    data = await _read_request_body(request=request)
+    data["response_id"] = response_id
+    processor = ProxyBaseLLMRequestProcessing(data=data)
+    #processor = ProxyBaseLLMRequestProcessing()
+
+    try:
+        return await processor.base_process_llm_request(
+            request=request,
+            fastapi_response=fastapi_response,
+            user_api_key_dict=user_api_key_dict,
+            route_type="aget_responses",
+            proxy_logging_obj=proxy_logging_obj,
+            llm_router=llm_router,
+            general_settings=general_settings,
+            proxy_config=proxy_config,
+            select_data_generator=select_data_generator,
+            model=None,
+            user_model=user_model,
+            user_temperature=user_temperature,
+            user_request_timeout=user_request_timeout,
+            user_max_tokens=user_max_tokens,
+            user_api_base=user_api_base,
+            version=version,
+        )
+    except Exception as e:
+        raise await processor._handle_llm_api_exception(
+            e=e,
+            user_api_key_dict=user_api_key_dict,
+            proxy_logging_obj=proxy_logging_obj,
+            version=version,
+        )
 
 
 @router.delete(
@@ -137,7 +182,53 @@ async def delete_response(
     ```
     """
     # TODO: Implement response deletion logic
-    pass
+    from litellm.proxy.proxy_server import (
+        _read_request_body,
+        general_settings,
+        llm_router,
+        proxy_config,
+        proxy_logging_obj,
+        select_data_generator,
+        user_api_base,
+        user_max_tokens,
+        user_model,
+        user_request_timeout,
+        user_temperature,
+        version,
+    )
+
+    data = await _read_request_body(request=request)
+    data["response_id"] = response_id
+    processor = ProxyBaseLLMRequestProcessing(data=data)
+    #processor = ProxyBaseLLMRequestProcessing()
+
+    try:
+        return await processor.base_process_llm_request(
+            request=request,
+            fastapi_response=fastapi_response,
+            user_api_key_dict=user_api_key_dict,
+            route_type="adelete_responses",
+            proxy_logging_obj=proxy_logging_obj,
+            llm_router=llm_router,
+            general_settings=general_settings,
+            proxy_config=proxy_config,
+            select_data_generator=select_data_generator,
+            model=None,
+            user_model=user_model,
+            user_temperature=user_temperature,
+            user_request_timeout=user_request_timeout,
+            user_max_tokens=user_max_tokens,
+            user_api_base=user_api_base,
+            version=version,
+        )
+    except Exception as e:
+        raise await processor._handle_llm_api_exception(
+            e=e,
+            user_api_key_dict=user_api_key_dict,
+            proxy_logging_obj=proxy_logging_obj,
+            version=version,
+        )
+
 
 
 @router.get(

litellm/proxy/route_llm_request.py

@@ -47,6 +47,8 @@ async def route_request(
         "amoderation",
         "arerank",
         "aresponses",
+        "aget_responses",
+        "adelete_responses",
         "_arealtime",  # private function for realtime API
     ],
 ):

litellm/router.py

@@ -732,6 +732,12 @@ def initialize_router_endpoints(self):
         self.aresponses = self.factory_function(
             litellm.aresponses, call_type="aresponses"
         )
+        self.aget_responses = self.factory_function(
+            litellm.aget_responses, call_type="aget_responses"
+        )
+        self.adelete_responses = self.factory_function(
+            litellm.adelete_responses, call_type="adelete_responses"
+        )
         self.afile_delete = self.factory_function(
             litellm.afile_delete, call_type="afile_delete"
         )
@@ -2416,6 +2422,14 @@ async def _aadapter_completion(self, adapter_id: str, model: str, **kwargs):
                 self.fail_calls[model] += 1
             raise e
 
+    def retrieve_responses_model(
+        self, response_id: str
+    ):
+        from litellm.responses.utils import ResponsesAPIRequestUtils
+        decoded_result = ResponsesAPIRequestUtils._decode_responses_api_response_id(response_id)
+        model_id = decoded_result.get("model_id")
+        return model_id
+
     async def _ageneric_api_call_with_fallbacks(
         self, model: str, original_function: Callable, **kwargs
     ):
@@ -3080,6 +3094,8 @@ def factory_function(
             "moderation",
             "anthropic_messages",
             "aresponses",
+            "aget_responses",
+            "adelete_responses",
             "responses",
             "afile_delete",
             "afile_content",
@@ -3130,7 +3146,11 @@ async def async_wrapper(
             elif call_type in (
                 "anthropic_messages",
                 "aresponses",
+                "aget_responses",
+                "adelete_responses"
             ):
+                if call_type == "aget_responses" or call_type == "adelete_responses":
+                    kwargs['model'] = self.retrieve_responses_model(kwargs["response_id"])
                 return await self._ageneric_api_call_with_fallbacks(
                     original_function=original_function,
                     **kwargs,