Add ChatGPT subscription support and responses bridge

docs/my-website/docs/providers/chatgpt.md

@@ -0,0 +1,84 @@
+# ChatGPT Subscription
+
+Use ChatGPT Pro/Max subscription models through LiteLLM with OAuth device flow authentication.
+
+| Property | Details |
+|-------|-------|
+| Description | ChatGPT subscription access (Codex + GPT-5.2 family) via ChatGPT backend API |
+| Provider Route on LiteLLM | `chatgpt/` |
+| Supported Endpoints | `/responses`, `/chat/completions` (bridged to Responses for supported models) |
+| API Reference | https://chatgpt.com |
+
+ChatGPT subscription access is native to the Responses API. Chat Completions requests are bridged to Responses for supported models (for example `chatgpt/gpt-5.2`).
+
+Notes:
+- The ChatGPT subscription backend rejects token limit fields (`max_tokens`, `max_output_tokens`, `max_completion_tokens`) and `metadata`. LiteLLM strips these fields for this provider.
+- `/v1/chat/completions` honors `stream`. When `stream` is false (default), LiteLLM aggregates the Responses stream into a single JSON response.
+
+## Authentication
+
+ChatGPT subscription access uses an OAuth device code flow:
+
+1. LiteLLM prints a device code and verification URL
+2. Open the URL, sign in, and enter the code
+3. Tokens are stored locally for reuse
+
+## Usage - LiteLLM Python SDK
+
+### Responses (recommended for Codex models)
+
+```python showLineNumbers title="ChatGPT Responses"
+import litellm
+
+response = litellm.responses(
+    model="chatgpt/gpt-5.2-codex",
+    input="Write a Python hello world"
+)
+
+print(response)
+```
+
+### Chat Completions (bridged to Responses)
+
+```python showLineNumbers title="ChatGPT Chat Completions"
+import litellm
+
+response = litellm.completion(
+    model="chatgpt/gpt-5.2",
+    messages=[{"role": "user", "content": "Write a Python hello world"}]
+)
+
+print(response)
+```
+
+## Usage - LiteLLM Proxy
+
+```yaml showLineNumbers title="config.yaml"
+model_list:
+  - model_name: chatgpt/gpt-5.2
+    model_info:
+      mode: responses
+    litellm_params:
+      model: chatgpt/gpt-5.2
+  - model_name: chatgpt/gpt-5.2-codex
+    model_info:
+      mode: responses
+    litellm_params:
+      model: chatgpt/gpt-5.2-codex
+```
+
+```bash showLineNumbers title="Start LiteLLM Proxy"
+litellm --config config.yaml
+```
+
+## Configuration
+
+### Environment Variables
+
+- `CHATGPT_TOKEN_DIR`: Custom token storage directory
+- `CHATGPT_AUTH_FILE`: Auth file name (default: `auth.json`)
+- `CHATGPT_API_BASE`: Override API base (default: `https://chatgpt.com/backend-api/codex`)
+- `OPENAI_CHATGPT_API_BASE`: Alias for `CHATGPT_API_BASE`
+- `CHATGPT_ORIGINATOR`: Override the `originator` header value
+- `CHATGPT_USER_AGENT`: Override the `User-Agent` header value
+- `CHATGPT_USER_AGENT_SUFFIX`: Optional suffix appended to the `User-Agent` header

docs/my-website/sidebars.js

@@ -691,6 +691,7 @@ const sidebars = {
         "providers/galadriel",
         "providers/github",
         "providers/github_copilot",
+        "providers/chatgpt",
         "providers/gradient_ai",
         "providers/groq",
         "providers/helicone",

litellm/__init__.py

@@ -557,6 +557,7 @@ def identify(event_details):
 amazon_nova_models: Set = set()
 stability_models: Set = set()
 github_copilot_models: Set = set()
+chatgpt_models: Set = set()
 minimax_models: Set = set()
 aws_polly_models: Set = set()
 gigachat_models: Set = set()
@@ -812,6 +813,8 @@ def add_known_models():
             stability_models.add(key)
         elif value.get("litellm_provider") == "github_copilot":
             github_copilot_models.add(key)
+        elif value.get("litellm_provider") == "chatgpt":
+            chatgpt_models.add(key)
         elif value.get("litellm_provider") == "minimax":
             minimax_models.add(key)
         elif value.get("litellm_provider") == "aws_polly":
@@ -1025,6 +1028,7 @@ def add_known_models():
     "amazon_nova": amazon_nova_models,
     "stability": stability_models,
     "github_copilot": github_copilot_models,
+    "chatgpt": chatgpt_models,
     "minimax": minimax_models,
     "aws_polly": aws_polly_models,
     "gigachat": gigachat_models,
@@ -1458,6 +1462,8 @@ def set_global_gitlab_config(config: Dict[str, Any]) -> None:
     from .llms.github_copilot.chat.transformation import GithubCopilotConfig as GithubCopilotConfig
     from .llms.github_copilot.responses.transformation import GithubCopilotResponsesAPIConfig as GithubCopilotResponsesAPIConfig
     from .llms.github_copilot.embedding.transformation import GithubCopilotEmbeddingConfig as GithubCopilotEmbeddingConfig
+    from .llms.chatgpt.chat.transformation import ChatGPTConfig as ChatGPTConfig
+    from .llms.chatgpt.responses.transformation import ChatGPTResponsesAPIConfig as ChatGPTResponsesAPIConfig
     from .llms.gigachat.chat.transformation import GigaChatConfig as GigaChatConfig
     from .llms.gigachat.embedding.transformation import GigaChatEmbeddingConfig as GigaChatEmbeddingConfig
     from .llms.nebius.chat.transformation import NebiusConfig as NebiusConfig

litellm/_lazy_imports_registry.py

@@ -253,6 +253,8 @@
     "IBMWatsonXAudioTranscriptionConfig",
     "GithubCopilotConfig",
     "GithubCopilotResponsesAPIConfig",
+    "ChatGPTConfig",
+    "ChatGPTResponsesAPIConfig",
     "ManusResponsesAPIConfig",
     "GithubCopilotEmbeddingConfig",
     "NebiusConfig",
@@ -648,6 +650,8 @@
     "GithubCopilotConfig": (".llms.github_copilot.chat.transformation", "GithubCopilotConfig"),
     "GithubCopilotResponsesAPIConfig": (".llms.github_copilot.responses.transformation", "GithubCopilotResponsesAPIConfig"),
     "GithubCopilotEmbeddingConfig": (".llms.github_copilot.embedding.transformation", "GithubCopilotEmbeddingConfig"),
+    "ChatGPTConfig": (".llms.chatgpt.chat.transformation", "ChatGPTConfig"),
+    "ChatGPTResponsesAPIConfig": (".llms.chatgpt.responses.transformation", "ChatGPTResponsesAPIConfig"),
     "NebiusConfig": (".llms.nebius.chat.transformation", "NebiusConfig"),
     "WandbConfig": (".llms.wandb.chat.transformation", "WandbConfig"),
     "GigaChatConfig": (".llms.gigachat.chat.transformation", "GigaChatConfig"),

litellm/completion_extras/litellm_responses_transformation/handler.py

@@ -2,12 +2,13 @@
 Handler for transforming /chat/completions api requests to litellm.responses requests
 """
 
-from typing import TYPE_CHECKING, Any, Coroutine, Union
+from typing import TYPE_CHECKING, Any, Coroutine, Optional, Union
 
 from typing_extensions import TypedDict
 
 if TYPE_CHECKING:
     from litellm import CustomStreamWrapper, LiteLLMLoggingObj, ModelResponse
+    from litellm.types.llms.openai import ResponsesAPIResponse
 
 
 class ResponsesToCompletionBridgeHandlerInputKwargs(TypedDict):
@@ -28,6 +29,77 @@ def __init__(self):
         super().__init__()
         self.transformation_handler = LiteLLMResponsesTransformationHandler()
 
+    @staticmethod
+    def _resolve_stream_flag(optional_params: dict, litellm_params: dict) -> bool:
+        stream = optional_params.get("stream")
+        if stream is None:
+            stream = litellm_params.get("stream", False)
+        return bool(stream)
+
+    @staticmethod
+    def _coerce_response_object(
+        response_obj: Any,
+        hidden_params: Optional[dict],
+    ) -> "ResponsesAPIResponse":
+        from litellm.types.llms.openai import ResponsesAPIResponse
+
+        if isinstance(response_obj, ResponsesAPIResponse):
+            response = response_obj
+        elif isinstance(response_obj, dict):
+            try:
+                response = ResponsesAPIResponse(**response_obj)
+            except Exception:
+                response = ResponsesAPIResponse.model_construct(**response_obj)
+        else:
+            raise ValueError("Unexpected responses stream payload")
+
+        if hidden_params:
+            existing = getattr(response, "_hidden_params", None)
+            if not isinstance(existing, dict) or not existing:
+                setattr(response, "_hidden_params", dict(hidden_params))
+            else:
+                for key, value in hidden_params.items():
+                    existing.setdefault(key, value)
+        return response
+
+    def _collect_response_from_stream(
+        self, stream_iter: Any
+    ) -> "ResponsesAPIResponse":
+        from litellm.types.llms.openai import ResponsesAPIResponse
+
+        for _ in stream_iter:
+            pass
+
+        completed = getattr(stream_iter, "completed_response", None)
+        response_obj = getattr(completed, "response", None) if completed else None
+        if response_obj is None:
+            raise ValueError("Stream ended without a completed response")
+
+        hidden_params = getattr(stream_iter, "_hidden_params", None)
+        response = self._coerce_response_object(response_obj, hidden_params)
+        if not isinstance(response, ResponsesAPIResponse):
+            raise ValueError("Stream completed response is invalid")
+        return response
+
+    async def _collect_response_from_stream_async(
+        self, stream_iter: Any
+    ) -> "ResponsesAPIResponse":
+        from litellm.types.llms.openai import ResponsesAPIResponse
+
+        async for _ in stream_iter:
+            pass
+
+        completed = getattr(stream_iter, "completed_response", None)
+        response_obj = getattr(completed, "response", None) if completed else None
+        if response_obj is None:
+            raise ValueError("Stream ended without a completed response")
+
+        hidden_params = getattr(stream_iter, "_hidden_params", None)
+        response = self._coerce_response_object(response_obj, hidden_params)
+        if not isinstance(response, ResponsesAPIResponse):
+            raise ValueError("Stream completed response is invalid")
+        return response
+
     def validate_input_kwargs(
         self, kwargs: dict
     ) -> ResponsesToCompletionBridgeHandlerInputKwargs:
@@ -113,6 +185,7 @@ def completion(self, *args, **kwargs) -> Union[
             **request_data,
         )
 
+        stream = self._resolve_stream_flag(optional_params, litellm_params)
         if isinstance(result, ResponsesAPIResponse):
             return self.transformation_handler.transform_response(
                 model=model,
@@ -127,6 +200,21 @@ def completion(self, *args, **kwargs) -> Union[
                 api_key=kwargs.get("api_key"),
                 json_mode=kwargs.get("json_mode"),
             )
+        elif not stream:
+            responses_api_response = self._collect_response_from_stream(result)
+            return self.transformation_handler.transform_response(
+                model=model,
+                raw_response=responses_api_response,
+                model_response=model_response,
+                logging_obj=logging_obj,
+                request_data=request_data,
+                messages=messages,
+                optional_params=optional_params,
+                litellm_params=litellm_params,
+                encoding=kwargs.get("encoding"),
+                api_key=kwargs.get("api_key"),
+                json_mode=kwargs.get("json_mode"),
+            )
         else:
             completion_stream = self.transformation_handler.get_model_response_iterator(
                 streaming_response=result,  # type: ignore
@@ -175,6 +263,7 @@ async def acompletion(
             aresponses=True,
         )
 
+        stream = self._resolve_stream_flag(optional_params, litellm_params)
         if isinstance(result, ResponsesAPIResponse):
             return self.transformation_handler.transform_response(
                 model=model,
@@ -189,6 +278,23 @@ async def acompletion(
                 api_key=kwargs.get("api_key"),
                 json_mode=kwargs.get("json_mode"),
             )
+        elif not stream:
+            responses_api_response = await self._collect_response_from_stream_async(
+                result
+            )
+            return self.transformation_handler.transform_response(
+                model=model,
+                raw_response=responses_api_response,
+                model_response=model_response,
+                logging_obj=logging_obj,
+                request_data=request_data,
+                messages=messages,
+                optional_params=optional_params,
+                litellm_params=litellm_params,
+                encoding=kwargs.get("encoding"),
+                api_key=kwargs.get("api_key"),
+                json_mode=kwargs.get("json_mode"),
+            )
         else:
             completion_stream = self.transformation_handler.get_model_response_iterator(
                 streaming_response=result,  # type: ignore

litellm/constants.py

@@ -405,6 +405,7 @@
     "galadriel",
     "gradient_ai",
     "github_copilot",  # GitHub Copilot Chat API
+    "chatgpt",  # ChatGPT subscription API
     "novita",
     "meta_llama",
     "featherless_ai",
@@ -603,6 +604,7 @@
     "lm_studio",
     "galadriel",
     "github_copilot",  # GitHub Copilot Chat API
+    "chatgpt",  # ChatGPT subscription API
     "novita",
     "meta_llama",
     "publicai",  # PublicAI - JSON-configured provider

litellm/litellm_core_utils/get_llm_provider_logic.py

@@ -768,6 +768,14 @@ def _get_openai_compatible_provider_info(  # noqa: PLR0915
         ) = litellm.GithubCopilotConfig()._get_openai_compatible_provider_info(
             model, api_base, api_key, custom_llm_provider
         )
+    elif custom_llm_provider == "chatgpt":
+        (
+            api_base,
+            dynamic_api_key,
+            custom_llm_provider,
+        ) = litellm.ChatGPTConfig()._get_openai_compatible_provider_info(
+            model, api_base, api_key, custom_llm_provider
+        )
     elif custom_llm_provider == "novita":
         api_base = (
             api_base