Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
feat: add chatgpt oauth client for codex routing (#8774)
jnjpng5017cb1d129c
diff --git a/letta/adapters/simple_llm_stream_adapter.py b/letta/adapters/simple_llm_stream_adapter.pyindex 0d3f7974a..ff3eca312 100644--- a/letta/adapters/simple_llm_stream_adapter.py+++ b/letta/adapters/simple_llm_stream_adapter.py@@ -2,6 +2,9 @@ import jsonfrom typing import AsyncGenerator, Listfrom letta.adapters.letta_llm_stream_adapter import LettaLLMStreamAdapter+from letta.log import get_logger++logger = get_logger(__name__)from letta.helpers.datetime_helpers import get_utc_timestamp_nsfrom letta.interfaces.anthropic_parallel_tool_call_streaming_interface import SimpleAnthropicStreamingInterfacefrom letta.interfaces.gemini_streaming_interface import SimpleGeminiStreamingInterface@@ -75,12 +78,22 @@ class SimpleLLMStreamAdapter(LettaLLMStreamAdapter):run_id=self.run_id,step_id=step_id,)- elif self.llm_config.model_endpoint_type in [ProviderType.openai, ProviderType.deepseek, ProviderType.zai]:+ elif self.llm_config.model_endpoint_type in [+ ProviderType.openai,+ ProviderType.deepseek,+ ProviderType.zai,+ ProviderType.chatgpt_oauth,+ ]:# Decide interface based on payload shapeuse_responses = "input" in request_data and "messages" not in request_data# No support for Responses API proxyis_proxy = self.llm_config.provider_name == "lmstudio_openai"+ # ChatGPT OAuth always uses Responses API format+ if self.llm_config.model_endpoint_type == ProviderType.chatgpt_oauth:+ use_responses = True+ is_proxy = False+if use_responses and not is_proxy:self.interface = SimpleOpenAIResponsesStreamingInterface(is_openai_proxy=False,@@ -109,9 +122,6 @@ class SimpleLLMStreamAdapter(LettaLLMStreamAdapter):else:raise ValueError(f"Streaming not supported for provider {self.llm_config.model_endpoint_type}")- # Extract optional parameters- # ttft_span = kwargs.get('ttft_span', None)-# Start the streaming request (map provider errors to common LLMError types)try:# Gemini uses async generator pattern (no await) to maintain connection lifecyclediff --git a/letta/llm_api/chatgpt_oauth_client.py b/letta/llm_api/chatgpt_oauth_client.pynew file mode 100644index 000000000..6819ac956--- /dev/null+++ b/letta/llm_api/chatgpt_oauth_client.py@@ -0,0 +1,1036 @@+"""ChatGPT OAuth Client - handles requests to chatgpt.com/backend-api/codex/responses."""++import json+from typing import Any, AsyncIterator, Callable, Dict, List, Optional, Union++import httpx+from openai import AsyncStream+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk+from openai.types.responses import (+ Response,+ ResponseCompletedEvent,+ ResponseContentPartAddedEvent,+ ResponseContentPartDoneEvent,+ ResponseCreatedEvent,+ ResponseFunctionCallArgumentsDeltaEvent,+ ResponseFunctionCallArgumentsDoneEvent,+ ResponseFunctionToolCall,+ ResponseInProgressEvent,+ ResponseOutputItemAddedEvent,+ ResponseOutputItemDoneEvent,+ ResponseOutputMessage,+ ResponseOutputText,+ ResponseReasoningItem,+ ResponseReasoningSummaryPartAddedEvent,+ ResponseReasoningSummaryPartDoneEvent,+ ResponseReasoningSummaryTextDeltaEvent,+ ResponseReasoningSummaryTextDoneEvent,+ ResponseTextDeltaEvent,+ ResponseTextDoneEvent,+)+from openai.types.responses.response_stream_event import ResponseStreamEvent++from letta.errors import (+ ContextWindowExceededError,+ ErrorCode,+ LLMAuthenticationError,+ LLMBadRequestError,+ LLMConnectionError,+ LLMRateLimitError,+ LLMServerError,+ LLMTimeoutError,+)+from letta.llm_api.llm_client_base import LLMClientBase+from letta.log import get_logger+from letta.otel.tracing import trace_method+from letta.schemas.enums import AgentType, ProviderCategory+from letta.schemas.llm_config import LLMConfig+from letta.schemas.message import Message as PydanticMessage+from letta.schemas.openai.chat_completion_response import (+ ChatCompletionResponse,+ Choice,+ FunctionCall,+ Message as ChoiceMessage,+ ToolCall,+ UsageStatistics,+)+from letta.schemas.providers.chatgpt_oauth import ChatGPTOAuthCredentials, ChatGPTOAuthProvider++logger = get_logger(__name__)++# ChatGPT Backend API endpoint+CHATGPT_CODEX_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses"+++class AsyncStreamWrapper:+ """Wraps an async generator to provide async context manager protocol.++ The OpenAI SDK's AsyncStream implements __aenter__ and __aexit__,+ but our custom SSE handler returns a raw async generator. This wrapper+ provides the context manager protocol so it can be used with 'async with'.+ """++ def __init__(self, generator: AsyncIterator[ResponseStreamEvent]):+ self._generator = generator++ async def __aenter__(self):+ return self++ async def __aexit__(self, exc_type, exc_val, exc_tb):+ # Close the generator if it has an aclose method+ if hasattr(self._generator, "aclose"):+ await self._generator.aclose()+ return False++ def __aiter__(self):+ return self++ async def __anext__(self) -> ResponseStreamEvent:+ return await self._generator.__anext__()+++class ChatGPTOAuthClient(LLMClientBase):+ """+ LLM client for ChatGPT OAuth provider.++ This client:+ 1. Transforms standard OpenAI chat format to ChatGPT backend Responses API format+ 2. Adds required headers (Authorization, ChatGPT-Account-Id, OpenAI-Beta, OpenAI-Originator)+ 3. Makes requests to chatgpt.com/backend-api/codex/responses+ 4. Transforms responses back to OpenAI ChatCompletion format+ """++ @trace_method+ async def _get_provider_and_credentials_async(self, llm_config: LLMConfig) -> tuple[ChatGPTOAuthProvider, ChatGPTOAuthCredentials]:+ """Get the ChatGPT OAuth provider and credentials with automatic refresh if needed.++ Args:+ llm_config: The LLM configuration containing provider info.++ Returns:+ Tuple of (provider, credentials).++ Raises:+ LLMAuthenticationError: If credentials cannot be obtained.+ """+ from letta.services.provider_manager import ProviderManager++ if llm_config.provider_category != ProviderCategory.byok:+ raise ValueError("ChatGPT OAuth requires BYOK provider credentials")++ # Get provider+ provider_manager = ProviderManager()+ providers = await provider_manager.list_providers_async(+ name=llm_config.provider_name,+ actor=self.actor,+ provider_category=[ProviderCategory.byok],+ )++ if not providers:+ raise LLMAuthenticationError(+ message=f"ChatGPT OAuth provider '{llm_config.provider_name}' not found",+ code=ErrorCode.UNAUTHENTICATED,+ )++ provider: ChatGPTOAuthProvider = providers[0].cast_to_subtype()++ # Get credentials with automatic refresh (pass actor for persistence)+ creds = await provider.refresh_token_if_needed(actor=self.actor)+ if not creds:+ raise LLMAuthenticationError(+ message="Failed to obtain valid ChatGPT OAuth credentials",+ code=ErrorCode.UNAUTHENTICATED,+ )++ return provider, creds++ def _build_headers(self, creds: ChatGPTOAuthCredentials) -> Dict[str, str]:+ """Build required headers for ChatGPT backend API.++ Args:+ creds: OAuth credentials containing access_token and account_id.++ Returns:+ Dictionary of HTTP headers.+ """+ return {+ "Authorization": f"Bearer {creds.access_token}",+ "ChatGPT-Account-Id": creds.account_id,+ "OpenAI-Beta": "responses=v1",+ "OpenAI-Originator": "codex",+ "Content-Type": "application/json",+ "accept": "text/event-stream",+ }++ @trace_method+ def build_request_data(+ self,+ agent_type: AgentType,+ messages: List[PydanticMessage],+ llm_config: LLMConfig,+ tools: Optional[List[dict]] = None,+ force_tool_call: Optional[str] = None,+ requires_subsequent_tool_call: bool = False,+ tool_return_truncation_chars: Optional[int] = None,+ ) -> dict:+ """+ Build request data for ChatGPT backend API in Responses API format.++ The ChatGPT backend uses the OpenAI Responses API format:+ - `input` array instead of `messages`+ - `role: "developer"` instead of `role: "system"`+ - Structured content arrays+ """+ # Use the existing method to convert messages to Responses API format+ input_messages = PydanticMessage.to_openai_responses_dicts_from_list(+ messages,+ tool_return_truncation_chars=tool_return_truncation_chars,+ )++ # Extract system message as instructions+ instructions = None+ filtered_input = []+ for msg in input_messages:+ if msg.get("role") == "developer":+ # First developer message becomes instructions+ if instructions is None:+ content = msg.get("content", [])+ if isinstance(content, list) and content:+ instructions = content[0].get("text", "")+ elif isinstance(content, str):+ instructions = content+ else:+ filtered_input.append(msg)+ else:+ filtered_input.append(msg)++ # Build tool_choice+ tool_choice = None+ if tools:+ if force_tool_call is not None:+ tool_choice = {"type": "function", "name": force_tool_call}+ elif requires_subsequent_tool_call:+ tool_choice = "required"+ else:+ tool_choice = "auto"++ # Build request payload for ChatGPT backend+ data: Dict[str, Any] = {+ "model": llm_config.model,+ "input": filtered_input,+ "store": False, # Required for stateless operation+ "stream": True, # ChatGPT backend requires streaming+ }++ if instructions:+ data["instructions"] = instructions++ if tools:+ # Convert tools to Responses API format+ responses_tools = [+ {+ "type": "function",+ "name": t.get("name"),+ "description": t.get("description"),+ "parameters": t.get("parameters"),+ }+ for t in tools+ ]+ data["tools"] = responses_tools+ data["tool_choice"] = tool_choice++ # Note: ChatGPT backend does NOT support max_output_tokens parameter++ # Add reasoning effort for reasoning models (GPT-5.x, o-series)+ if self.is_reasoning_model(llm_config) and llm_config.reasoning_effort:+ data["reasoning"] = {+ "effort": llm_config.reasoning_effort,+ "summary": "detailed",+ }++ return data++ def _transform_response_from_chatgpt_backend(self, response_data: dict) -> dict:+ """Transform ChatGPT backend response to standard OpenAI ChatCompletion format.++ The ChatGPT backend returns responses in Responses API format.+ This method normalizes them to ChatCompletion format.++ Args:+ response_data: Raw response from ChatGPT backend.++ Returns:+ Response in OpenAI ChatCompletion format.+ """+ # If response is already in ChatCompletion format, return as-is+ if "choices" in response_data:+ return response_data++ # Extract from Responses API format+ output = response_data.get("output", [])+ message_content = ""+ tool_calls = None+ reasoning_content = ""++ for item in output:+ item_type = item.get("type")++ if item_type == "message":+ content_parts = item.get("content", [])+ for part in content_parts:+ if part.get("type") in ("output_text", "text"):+ message_content += part.get("text", "")+ elif part.get("type") == "refusal":+ message_content += part.get("refusal", "")++ elif item_type == "function_call":+ if tool_calls is None:+ tool_calls = []+ tool_calls.append(+ {+ "id": item.get("call_id", item.get("id", "")),+ "type": "function",+ "function": {+ "name": item.get("name", ""),+ "arguments": item.get("arguments", ""),+ },+ }+ )++ elif item_type == "reasoning":+ # Capture reasoning/thinking content if present+ summary = item.get("summary", [])+ for s in summary:+ if s.get("type") == "summary_text":+ reasoning_content += s.get("text", "")++ # Build ChatCompletion response+ finish_reason = "stop"+ if tool_calls:+ finish_reason = "tool_calls"++ transformed = {+ "id": response_data.get("id", "chatgpt-response"),+ "object": "chat.completion",+ "created": response_data.get("created_at", 0),+ "model": response_data.get("model", ""),+ "choices": [+ {+ "index": 0,+ "message": {+ "role": "assistant",+ "content": message_content or None,+ "tool_calls": tool_calls,+ },+ "finish_reason": finish_reason,+ }+ ],+ "usage": self._transform_usage(response_data.get("usage", {})),+ }++ return transformed++ def _transform_usage(self, usage: dict) -> dict:+ """Transform usage statistics from Responses API format."""+ return {+ "prompt_tokens": usage.get("input_tokens", 0),+ "completion_tokens": usage.get("output_tokens", 0),+ "total_tokens": usage.get("input_tokens", 0) + usage.get("output_tokens", 0),+ }++ @trace_method+ def request(self, request_data: dict, llm_config: LLMConfig) -> dict:+ """Synchronous request - not recommended for ChatGPT OAuth."""+ import asyncio++ return asyncio.run(self.request_async(request_data, llm_config))++ @trace_method+ async def request_async(self, request_data: dict, llm_config: LLMConfig) -> dict:+ """Make asynchronous request to ChatGPT backend API.++ Args:+ request_data: Request payload in Responses API format.+ llm_config: LLM configuration.++ Returns:+ Response data in OpenAI ChatCompletion format.+ """+ logger.info("ChatGPT OAuth request_async called (non-streaming path)")+ _, creds = await self._get_provider_and_credentials_async(llm_config)+ headers = self._build_headers(creds)++ endpoint = llm_config.model_endpoint or CHATGPT_CODEX_ENDPOINT++ # ChatGPT backend requires streaming, so we use client.stream() to handle SSE+ async with httpx.AsyncClient() as client:+ try:+ async with client.stream(+ "POST",+ endpoint,+ json=request_data,+ headers=headers,+ timeout=120.0,+ ) as response:+ response.raise_for_status()+ # Accumulate SSE events into a final response+ return await self._accumulate_sse_response(response)++ except httpx.HTTPStatusError as e:+ raise self._handle_http_error(e)+ except httpx.TimeoutException:+ raise LLMTimeoutError(+ message="ChatGPT backend request timed out",+ code=ErrorCode.TIMEOUT,+ )+ except httpx.RequestError as e:+ raise LLMConnectionError(+ message=f"Failed to connect to ChatGPT backend: {str(e)}",+ code=ErrorCode.INTERNAL_SERVER_ERROR,+ )++ async def _accumulate_sse_response(self, response: httpx.Response) -> dict:+ """Accumulate SSE stream into a final response.++ ChatGPT backend may return SSE even for non-streaming requests.+ This method accumulates all events into a single response.++ Args:+ response: httpx Response object with SSE content.++ Returns:+ Accumulated response data.+ """+ accumulated_content = ""+ accumulated_tool_calls: List[Dict[str, Any]] = []+ model = ""+ response_id = ""+ usage = {}++ async for line in response.aiter_lines():+ if not line.startswith("data: "):+ continue++ data_str = line[6:] # Remove "data: " prefix+ if data_str == "[DONE]":+ break++ try:+ event = json.loads(data_str)+ except json.JSONDecodeError:+ continue++ # Extract response metadata+ if not response_id and event.get("id"):+ response_id = event["id"]+ if not model and event.get("model"):+ model = event["model"]+ if event.get("usage"):+ usage = event["usage"]++ # Handle different event types+ event_type = event.get("type")++ if event_type == "response.output_item.done":+ item = event.get("item", {})+ item_type = item.get("type")++ if item_type == "message":+ for content in item.get("content", []):+ if content.get("type") in ("output_text", "text"):+ accumulated_content += content.get("text", "")++ elif item_type == "function_call":+ accumulated_tool_calls.append(+ {+ "id": item.get("call_id", item.get("id", "")),+ "type": "function",+ "function": {+ "name": item.get("name", ""),+ "arguments": item.get("arguments", ""),+ },+ }+ )++ elif event_type == "response.content_part.delta":+ delta = event.get("delta", {})+ if delta.get("type") == "text_delta":+ accumulated_content += delta.get("text", "")++ elif event_type == "response.done":+ # Final response event+ if event.get("response", {}).get("usage"):+ usage = event["response"]["usage"]++ # Build final response+ finish_reason = "stop" if not accumulated_tool_calls else "tool_calls"++ return {+ "id": response_id or "chatgpt-response",+ "object": "chat.completion",+ "created": 0,+ "model": model,+ "choices": [+ {+ "index": 0,+ "message": {+ "role": "assistant",+ "content": accumulated_content or None,+ "tool_calls": accumulated_tool_calls if accumulated_tool_calls else None,+ },+ "finish_reason": finish_reason,+ }+ ],+ "usage": self._transform_usage(usage),+ }++ @trace_method+ async def request_embeddings(+ self,+ texts: List[str],+ embedding_config,+ ) -> List[List[float]]:+ """ChatGPT backend does not support embeddings."""+ raise NotImplementedError("ChatGPT OAuth does not support embeddings")++ @trace_method+ async def convert_response_to_chat_completion(+ self,+ response_data: dict,+ input_messages: List[PydanticMessage],+ llm_config: LLMConfig,+ ) -> ChatCompletionResponse:+ """Convert response to ChatCompletionResponse.++ Args:+ response_data: Response data (already in ChatCompletion format).+ input_messages: Original input messages.+ llm_config: LLM configuration.++ Returns:+ ChatCompletionResponse object.+ """+ # Response should already be in ChatCompletion format after transformation+ return ChatCompletionResponse(**response_data)++ @trace_method+ async def stream_async(+ self,+ request_data: dict,+ llm_config: LLMConfig,+ ) -> AsyncStream[ResponseStreamEvent]:+ """Stream response from ChatGPT backend.++ Note: ChatGPT backend uses SSE by default. This returns a custom+ async generator that yields ResponseStreamEvent objects compatible+ with the OpenAI SDK.++ Args:+ request_data: Request payload.+ llm_config: LLM configuration.++ Returns:+ Async generator yielding ResponseStreamEvent objects.+ """+ _, creds = await self._get_provider_and_credentials_async(llm_config)+ headers = self._build_headers(creds)++ endpoint = llm_config.model_endpoint or CHATGPT_CODEX_ENDPOINT++ async def stream_generator():+ event_count = 0+ # Track output item index for proper event construction+ output_index = 0+ # Track sequence_number in case backend doesn't provide it+ # (OpenAI SDK expects incrementing sequence numbers starting at 0)+ sequence_counter = 0++ async with httpx.AsyncClient() as client:+ async with client.stream(+ "POST",+ endpoint,+ json=request_data,+ headers=headers,+ timeout=120.0,+ ) as response:+ # Check for error status+ if response.status_code != 200:+ error_body = await response.aread()+ logger.error(f"ChatGPT SSE error: {response.status_code} - {error_body}")+ raise self._handle_http_error_from_status(response.status_code, error_body.decode())++ async for line in response.aiter_lines():+ if not line.startswith("data: "):+ continue++ data_str = line[6:]+ if data_str == "[DONE]":+ break++ try:+ raw_event = json.loads(data_str)+ event_type = raw_event.get("type")+ event_count += 1++ # Use backend-provided sequence_number if available, else use counter+ # This ensures proper ordering even if backend doesn't provide it+ if "sequence_number" not in raw_event:+ raw_event["sequence_number"] = sequence_counter+ sequence_counter = raw_event["sequence_number"] + 1++ # Track output index for output_item.added events+ if event_type == "response.output_item.added":+ output_index = raw_event.get("output_index", output_index)++ # Convert to OpenAI SDK ResponseStreamEvent+ sdk_event = self._convert_to_sdk_event(raw_event, output_index)+ if sdk_event:+ yield sdk_event++ except json.JSONDecodeError:+ logger.warning(f"Failed to parse SSE event: {data_str[:100]}")+ continue++ # Wrap the async generator in AsyncStreamWrapper to provide context manager protocol+ return AsyncStreamWrapper(stream_generator())++ def _convert_to_sdk_event(+ self,+ raw_event: dict,+ output_index: int = 0,+ ) -> Optional[ResponseStreamEvent]:+ """Convert raw ChatGPT backend SSE event to OpenAI SDK ResponseStreamEvent.++ Uses model_construct() to bypass validation since ChatGPT backend doesn't+ provide all fields required by OpenAI SDK (e.g., sequence_number).++ Args:+ raw_event: Raw SSE event data from ChatGPT backend.+ output_index: Current output item index.++ Returns:+ OpenAI SDK ResponseStreamEvent or None if event type not handled.+ """+ event_type = raw_event.get("type")+ response_id = raw_event.get("response_id", "")+ seq_num = raw_event.get("sequence_number", 0)++ # response.created -> ResponseCreatedEvent+ if event_type == "response.created":+ response_data = raw_event.get("response", {})+ return ResponseCreatedEvent.model_construct(+ type="response.created",+ sequence_number=seq_num,+ response=Response.model_construct(+ id=response_data.get("id", response_id),+ created_at=response_data.get("created_at", 0),+ model=response_data.get("model", ""),+ object="response",+ output=[],+ status=response_data.get("status", "in_progress"),+ parallel_tool_calls=response_data.get("parallel_tool_calls", True),+ ),+ )++ # response.in_progress -> ResponseInProgressEvent+ elif event_type == "response.in_progress":+ response_data = raw_event.get("response", {})+ return ResponseInProgressEvent.model_construct(+ type="response.in_progress",+ sequence_number=seq_num,+ response=Response.model_construct(+ id=response_data.get("id", response_id),+ created_at=response_data.get("created_at", 0),+ model=response_data.get("model", ""),+ object="response",+ output=[],+ status="in_progress",+ parallel_tool_calls=response_data.get("parallel_tool_calls", True),+ ),+ )++ # response.output_item.added -> ResponseOutputItemAddedEvent+ elif event_type == "response.output_item.added":+ item_data = raw_event.get("item", {})+ item_type = item_data.get("type")+ idx = raw_event.get("output_index", output_index)++ if item_type == "message":+ item = ResponseOutputMessage.model_construct(+ id=item_data.get("id", ""),+ type="message",+ role=item_data.get("role", "assistant"),+ content=[],+ status=item_data.get("status", "in_progress"),+ )+ elif item_type == "function_call":+ item = ResponseFunctionToolCall.model_construct(+ id=item_data.get("id", ""),+ type="function_call",+ call_id=item_data.get("call_id", ""),+ name=item_data.get("name", ""),+ arguments=item_data.get("arguments", ""),+ status=item_data.get("status", "in_progress"),+ )+ elif item_type == "reasoning":+ # Reasoning item for o-series, GPT-5 models+ item = ResponseReasoningItem.model_construct(+ id=item_data.get("id", ""),+ type="reasoning",+ summary=item_data.get("summary", []),+ status=item_data.get("status", "in_progress"),+ )+ else:+ # Unknown item type, skip+ return None++ return ResponseOutputItemAddedEvent.model_construct(+ type="response.output_item.added",+ sequence_number=seq_num,+ output_index=idx,+ item=item,+ )++ # response.content_part.added -> ResponseContentPartAddedEvent+ elif event_type == "response.content_part.added":+ part_data = raw_event.get("part", {})+ return ResponseContentPartAddedEvent.model_construct(+ type="response.content_part.added",+ sequence_number=seq_num,+ item_id=raw_event.get("item_id", ""),+ output_index=raw_event.get("output_index", output_index),+ content_index=raw_event.get("content_index", 0),+ part=ResponseOutputText.model_construct(+ type="output_text",+ text=part_data.get("text", ""),+ annotations=[],+ ),+ )++ # response.output_text.delta -> ResponseTextDeltaEvent+ # Note: OpenAI SDK uses "response.output_text.delta" (matching ChatGPT backend)+ elif event_type == "response.output_text.delta":+ return ResponseTextDeltaEvent.model_construct(+ type="response.output_text.delta",+ sequence_number=seq_num,+ item_id=raw_event.get("item_id", ""),+ output_index=raw_event.get("output_index", output_index),+ content_index=raw_event.get("content_index", 0),+ delta=raw_event.get("delta", ""),+ )++ # response.output_text.done -> ResponseTextDoneEvent+ elif event_type == "response.output_text.done":+ return ResponseTextDoneEvent.model_construct(+ type="response.output_text.done",+ sequence_number=seq_num,+ item_id=raw_event.get("item_id", ""),+ output_index=raw_event.get("output_index", output_index),+ content_index=raw_event.get("content_index", 0),+ text=raw_event.get("text", ""),+ )++ # response.function_call_arguments.delta -> ResponseFunctionCallArgumentsDeltaEvent+ elif event_type == "response.function_call_arguments.delta":+ return ResponseFunctionCallArgumentsDeltaEvent.model_construct(+ type="response.function_call_arguments.delta",+ sequence_number=seq_num,+ item_id=raw_event.get("item_id", ""),+ output_index=raw_event.get("output_index", output_index),+ call_id=raw_event.get("call_id", ""),+ delta=raw_event.get("delta", ""),+ )++ # response.function_call_arguments.done -> ResponseFunctionCallArgumentsDoneEvent+ elif event_type == "response.function_call_arguments.done":+ return ResponseFunctionCallArgumentsDoneEvent.model_construct(+ type="response.function_call_arguments.done",+ sequence_number=seq_num,+ item_id=raw_event.get("item_id", ""),+ output_index=raw_event.get("output_index", output_index),+ call_id=raw_event.get("call_id", ""),+ arguments=raw_event.get("arguments", ""),+ )++ # response.content_part.done -> ResponseContentPartDoneEvent+ elif event_type == "response.content_part.done":+ part_data = raw_event.get("part", {})+ return ResponseContentPartDoneEvent.model_construct(+ type="response.content_part.done",+ sequence_number=seq_num,+ item_id=raw_event.get("item_id", ""),+ output_index=raw_event.get("output_index", output_index),+ content_index=raw_event.get("content_index", 0),+ part=ResponseOutputText.model_construct(+ type="output_text",+ text=part_data.get("text", ""),+ annotations=[],+ ),+ )++ # response.output_item.done -> ResponseOutputItemDoneEvent+ elif event_type == "response.output_item.done":+ item_data = raw_event.get("item", {})+ item_type = item_data.get("type")+ idx = raw_event.get("output_index", output_index)++ if item_type == "message":+ # Build content from item data+ content_list = []+ for c in item_data.get("content", []):+ if c.get("type") in ("output_text", "text"):+ content_list.append(+ ResponseOutputText.model_construct(+ type="output_text",+ text=c.get("text", ""),+ annotations=[],+ )+ )+ item = ResponseOutputMessage.model_construct(+ id=item_data.get("id", ""),+ type="message",+ role=item_data.get("role", "assistant"),+ content=content_list,+ status=item_data.get("status", "completed"),+ )+ elif item_type == "function_call":+ item = ResponseFunctionToolCall.model_construct(+ id=item_data.get("id", ""),+ type="function_call",+ call_id=item_data.get("call_id", ""),+ name=item_data.get("name", ""),+ arguments=item_data.get("arguments", ""),+ status=item_data.get("status", "completed"),+ )+ elif item_type == "reasoning":+ # Build summary from item data+ summary_list = item_data.get("summary", [])+ item = ResponseReasoningItem.model_construct(+ id=item_data.get("id", ""),+ type="reasoning",+ summary=summary_list,+ status=item_data.get("status", "completed"),+ )+ else:+ return None++ return ResponseOutputItemDoneEvent.model_construct(+ type="response.output_item.done",+ sequence_number=seq_num,+ output_index=idx,+ item=item,+ )++ # response.completed or response.done -> ResponseCompletedEvent+ elif event_type in ("response.completed", "response.done"):+ response_data = raw_event.get("response", {})++ # Build output items from response data+ output_items = []+ for out in response_data.get("output", []):+ out_type = out.get("type")+ if out_type == "message":+ content_list = []+ for c in out.get("content", []):+ if c.get("type") in ("output_text", "text"):+ content_list.append(+ ResponseOutputText.model_construct(+ type="output_text",+ text=c.get("text", ""),+ annotations=[],+ )+ )+ output_items.append(+ ResponseOutputMessage.model_construct(+ id=out.get("id", ""),+ type="message",+ role=out.get("role", "assistant"),+ content=content_list,+ status=out.get("status", "completed"),+ )+ )+ elif out_type == "function_call":+ output_items.append(+ ResponseFunctionToolCall.model_construct(+ id=out.get("id", ""),+ type="function_call",+ call_id=out.get("call_id", ""),+ name=out.get("name", ""),+ arguments=out.get("arguments", ""),+ status=out.get("status", "completed"),+ )+ )++ return ResponseCompletedEvent.model_construct(+ type="response.completed",+ sequence_number=seq_num,+ response=Response.model_construct(+ id=response_data.get("id", response_id),+ created_at=response_data.get("created_at", 0),+ model=response_data.get("model", ""),+ object="response",+ output=output_items,+ status=response_data.get("status", "completed"),+ parallel_tool_calls=response_data.get("parallel_tool_calls", True),+ usage=response_data.get("usage"),+ ),+ )++ # Reasoning events (for o-series, GPT-5 models)+ # response.reasoning_summary_part.added -> ResponseReasoningSummaryPartAddedEvent+ elif event_type == "response.reasoning_summary_part.added":+ part_data = raw_event.get("part", {})+ # Use a simple dict for Part since we use model_construct+ part = {"text": part_data.get("text", ""), "type": part_data.get("type", "summary_text")}+ return ResponseReasoningSummaryPartAddedEvent.model_construct(+ type="response.reasoning_summary_part.added",+ sequence_number=seq_num,+ item_id=raw_event.get("item_id", ""),+ output_index=raw_event.get("output_index", output_index),+ summary_index=raw_event.get("summary_index", 0),+ part=part,+ )++ # response.reasoning_summary_text.delta -> ResponseReasoningSummaryTextDeltaEvent+ elif event_type == "response.reasoning_summary_text.delta":+ return ResponseReasoningSummaryTextDeltaEvent.model_construct(+ type="response.reasoning_summary_text.delta",+ sequence_number=seq_num,+ item_id=raw_event.get("item_id", ""),+ output_index=raw_event.get("output_index", output_index),+ summary_index=raw_event.get("summary_index", 0),+ delta=raw_event.get("delta", ""),+ )++ # response.reasoning_summary_text.done -> ResponseReasoningSummaryTextDoneEvent+ elif event_type == "response.reasoning_summary_text.done":+ return ResponseReasoningSummaryTextDoneEvent.model_construct(+ type="response.reasoning_summary_text.done",+ sequence_number=seq_num,+ item_id=raw_event.get("item_id", ""),+ output_index=raw_event.get("output_index", output_index),+ summary_index=raw_event.get("summary_index", 0),+ text=raw_event.get("text", ""),+ )++ # response.reasoning_summary_part.done -> ResponseReasoningSummaryPartDoneEvent+ elif event_type == "response.reasoning_summary_part.done":+ part_data = raw_event.get("part", {})+ part = {"text": part_data.get("text", ""), "type": part_data.get("type", "summary_text")}+ return ResponseReasoningSummaryPartDoneEvent.model_construct(+ type="response.reasoning_summary_part.done",+ sequence_number=seq_num,+ item_id=raw_event.get("item_id", ""),+ output_index=raw_event.get("output_index", output_index),+ summary_index=raw_event.get("summary_index", 0),+ part=part,+ )++ # Unhandled event types+ return None++ def _handle_http_error_from_status(self, status_code: int, error_body: str) -> Exception:+ """Create appropriate exception from HTTP status code.++ Args:+ status_code: HTTP status code.+ error_body: Error response body.++ Returns:+ Appropriate LLM exception.+ """+ if status_code == 401:+ return LLMAuthenticationError(+ message=f"ChatGPT authentication failed: {error_body}",+ code=ErrorCode.UNAUTHENTICATED,+ )+ elif status_code == 429:+ return LLMRateLimitError(+ message=f"ChatGPT rate limit exceeded: {error_body}",+ code=ErrorCode.RATE_LIMITED,+ )+ elif status_code >= 500:+ return LLMServerError(+ message=f"ChatGPT server error: {error_body}",+ code=ErrorCode.INTERNAL_SERVER_ERROR,+ )+ else:+ return LLMBadRequestError(+ message=f"ChatGPT request failed ({status_code}): {error_body}",+ code=ErrorCode.INTERNAL_SERVER_ERROR,+ )++ def is_reasoning_model(self, llm_config: LLMConfig) -> bool:+ """Check if model is a reasoning model.++ Args:+ llm_config: LLM configuration.++ Returns:+ True if model supports extended reasoning.+ """+ model = llm_config.model.lower()+ return "o1" in model or "o3" in model or "o4" in model or "gpt-5" in model++ @trace_method+ def handle_llm_error(self, e: Exception) -> Exception:+ """Map ChatGPT-specific errors to common LLMError types.++ Args:+ e: Original exception.++ Returns:+ Mapped LLMError subclass.+ """+ if isinstance(e, httpx.HTTPStatusError):+ return self._handle_http_error(e)++ return super().handle_llm_error(e)++ def _handle_http_error(self, e: httpx.HTTPStatusError) -> Exception:+ """Handle HTTP status errors from ChatGPT backend.++ Args:+ e: HTTP status error.++ Returns:+ Appropriate LLMError subclass.+ """+ status_code = e.response.status_code+ error_text = str(e)++ try:+ error_json = e.response.json()+ error_message = error_json.get("error", {}).get("message", error_text)+ except Exception:+ error_message = error_text++ if status_code == 401:+ return LLMAuthenticationError(+ message=f"ChatGPT authentication failed: {error_message}",+ code=ErrorCode.UNAUTHENTICATED,+ )+ elif status_code == 429:+ return LLMRateLimitError(+ message=f"ChatGPT rate limit exceeded: {error_message}",+ code=ErrorCode.RATE_LIMIT_EXCEEDED,+ )+ elif status_code == 400:+ if "context" in error_message.lower() or "token" in error_message.lower():+ return ContextWindowExceededError(+ message=f"ChatGPT context window exceeded: {error_message}",+ )+ return LLMBadRequestError(+ message=f"ChatGPT bad request: {error_message}",+ code=ErrorCode.INVALID_ARGUMENT,+ )+ elif status_code >= 500:+ return LLMServerError(+ message=f"ChatGPT server error: {error_message}",+ code=ErrorCode.INTERNAL_SERVER_ERROR,+ )+ else:+ return LLMBadRequestError(+ message=f"ChatGPT request failed ({status_code}): {error_message}",+ code=ErrorCode.INTERNAL_SERVER_ERROR,+ )diff --git a/letta/llm_api/llm_client.py b/letta/llm_api/llm_client.pyindex 264d7e2ff..805e40382 100644--- a/letta/llm_api/llm_client.py+++ b/letta/llm_api/llm_client.py@@ -100,6 +100,13 @@ class LLMClient:put_inner_thoughts_first=put_inner_thoughts_first,actor=actor,)+ case ProviderType.chatgpt_oauth:+ from letta.llm_api.chatgpt_oauth_client import ChatGPTOAuthClient++ return ChatGPTOAuthClient(+ put_inner_thoughts_first=put_inner_thoughts_first,+ actor=actor,+ )case _:from letta.llm_api.openai_client import OpenAIClientdiff --git a/letta/schemas/enums.py b/letta/schemas/enums.pyindex ecd66e188..41cc4d9cd 100644--- a/letta/schemas/enums.py+++ b/letta/schemas/enums.py@@ -55,6 +55,7 @@ class ProviderType(str, Enum):azure = "azure"bedrock = "bedrock"cerebras = "cerebras"+ chatgpt_oauth = "chatgpt_oauth"deepseek = "deepseek"google_ai = "google_ai"google_vertex = "google_vertex"diff --git a/letta/schemas/llm_config.py b/letta/schemas/llm_config.pyindex 3f1c484dc..5425fe129 100644--- a/letta/schemas/llm_config.py+++ b/letta/schemas/llm_config.py@@ -49,6 +49,7 @@ class LLMConfig(BaseModel):"deepseek","xai","zai",+ "chatgpt_oauth",] = Field(..., description="The endpoint type for the model.")model_endpoint: Optional[str] = Field(None, description="The endpoint for the model.")provider_name: Optional[str] = Field(None, description="The provider name for the model.")@@ -308,6 +309,8 @@ class LLMConfig(BaseModel):AnthropicThinking,AzureModelSettings,BedrockModelSettings,+ ChatGPTOAuthModelSettings,+ ChatGPTOAuthReasoning,DeepseekModelSettings,GeminiThinkingConfig,GoogleAIModelSettings,@@ -382,7 +385,16 @@ class LLMConfig(BaseModel):temperature=self.temperature,)elif self.model_endpoint_type == "bedrock":- return Model(max_output_tokens=self.max_tokens or 4096)+ return BedrockModelSettings(+ max_output_tokens=self.max_tokens or 4096,+ temperature=self.temperature,+ )+ elif self.model_endpoint_type == "chatgpt_oauth":+ return ChatGPTOAuthModelSettings(+ max_output_tokens=self.max_tokens or 4096,+ temperature=self.temperature,+ reasoning=ChatGPTOAuthReasoning(reasoning_effort=self.reasoning_effort or "medium"),+ )else:# If we don't know the model type, use the default Model schemareturn Model(max_output_tokens=self.max_tokens or 4096)diff --git a/letta/schemas/model.py b/letta/schemas/model.pyindex daf3291e3..7c059452e 100644--- a/letta/schemas/model.py+++ b/letta/schemas/model.py@@ -48,6 +48,7 @@ class Model(LLMConfig, ModelBase):"deepseek","xai","zai",+ "chatgpt_oauth",] = Field(..., description="Deprecated: Use 'provider_type' field instead. The endpoint type for the model.", deprecated=True)context_window: int = Field(..., description="Deprecated: Use 'max_context_window' field instead. The context window size for the model.", deprecated=True@@ -434,6 +435,32 @@ class BedrockModelSettings(ModelSettings):}+class ChatGPTOAuthReasoning(BaseModel):+ """Reasoning configuration for ChatGPT OAuth models (GPT-5.x, o-series)."""++ reasoning_effort: Literal["none", "low", "medium", "high", "xhigh"] = Field(+ "medium", description="The reasoning effort level for GPT-5.x and o-series models."+ )+++class ChatGPTOAuthModelSettings(ModelSettings):+ """ChatGPT OAuth model configuration (uses ChatGPT backend API)."""++ provider_type: Literal[ProviderType.chatgpt_oauth] = Field(ProviderType.chatgpt_oauth, description="The type of the provider.")+ temperature: float = Field(0.7, description="The temperature of the model.")+ reasoning: ChatGPTOAuthReasoning = Field(+ ChatGPTOAuthReasoning(reasoning_effort="medium"), description="The reasoning configuration for the model."+ )++ def _to_legacy_config_params(self) -> dict:+ return {+ "temperature": self.temperature,+ "max_tokens": self.max_output_tokens,+ "reasoning_effort": self.reasoning.reasoning_effort,+ "parallel_tool_calls": self.parallel_tool_calls,+ }++ModelSettingsUnion = Annotated[Union[OpenAIModelSettings,@@ -447,6 +474,7 @@ ModelSettingsUnion = Annotated[DeepseekModelSettings,TogetherModelSettings,BedrockModelSettings,+ ChatGPTOAuthModelSettings,],Field(discriminator="provider_type"),]diff --git a/letta/schemas/providers/__init__.py b/letta/schemas/providers/__init__.pyindex 8486ee51a..6e3f5187c 100644--- a/letta/schemas/providers/__init__.py+++ b/letta/schemas/providers/__init__.py@@ -5,6 +5,7 @@ from .azure import AzureProviderfrom .base import Provider, ProviderBase, ProviderCheck, ProviderCreate, ProviderUpdatefrom .bedrock import BedrockProviderfrom .cerebras import CerebrasProvider+from .chatgpt_oauth import ChatGPTOAuthProviderfrom .deepseek import DeepSeekProviderfrom .google_gemini import GoogleAIProviderfrom .google_vertex import GoogleVertexProvider@@ -31,7 +32,8 @@ __all__ = ["AnthropicProvider","AzureProvider","BedrockProvider",- "CerebrasProvider", # NEW+ "CerebrasProvider",+ "ChatGPTOAuthProvider","DeepSeekProvider","GoogleAIProvider","GoogleVertexProvider",diff --git a/letta/schemas/providers/base.py b/letta/schemas/providers/base.pyindex 1f11e8cdc..44e63f466 100644--- a/letta/schemas/providers/base.py+++ b/letta/schemas/providers/base.py@@ -184,6 +184,7 @@ class Provider(ProviderBase):AzureProvider,BedrockProvider,CerebrasProvider,+ ChatGPTOAuthProvider,DeepSeekProvider,GoogleAIProvider,GoogleVertexProvider,@@ -229,6 +230,8 @@ class Provider(ProviderBase):return DeepSeekProvider(**self.model_dump(exclude_none=True))case ProviderType.cerebras:return CerebrasProvider(**self.model_dump(exclude_none=True))+ case ProviderType.chatgpt_oauth:+ return ChatGPTOAuthProvider(**self.model_dump(exclude_none=True))case ProviderType.xai:return XAIProvider(**self.model_dump(exclude_none=True))case ProviderType.zai:diff --git a/letta/schemas/providers/chatgpt_oauth.py b/letta/schemas/providers/chatgpt_oauth.pynew file mode 100644index 000000000..8df9cd607--- /dev/null+++ b/letta/schemas/providers/chatgpt_oauth.py@@ -0,0 +1,366 @@+"""ChatGPT OAuth Provider - uses chatgpt.com/backend-api/codex with OAuth authentication."""++import json+from datetime import datetime+from typing import TYPE_CHECKING, Literal, Optional++import httpx+from pydantic import BaseModel, Field++from letta.errors import ErrorCode, LLMAuthenticationError, LLMError+from letta.log import get_logger+from letta.schemas.enums import ProviderCategory, ProviderType+from letta.schemas.llm_config import LLMConfig+from letta.schemas.providers.base import Provider+from letta.schemas.secret import Secret++if TYPE_CHECKING:+ from letta.orm import User++logger = get_logger(__name__)++# ChatGPT Backend API Configuration+CHATGPT_CODEX_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses"+CHATGPT_TOKEN_REFRESH_URL = "https://auth.openai.com/oauth/token"++# OAuth client_id for Codex CLI (required for token refresh)+# Must match the client_id used in the initial OAuth authorization flow+# This is the public client_id used by Codex CLI / Letta Code+CHATGPT_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann"++# Token refresh buffer (refresh 5 minutes before expiry)+TOKEN_REFRESH_BUFFER_SECONDS = 300++# Hardcoded models available via ChatGPT backend+# These are models that can be accessed through ChatGPT Plus/Pro subscriptions+# Model list based on opencode-openai-codex-auth plugin presets+# Reasoning effort levels are configured via llm_config.reasoning_effort+CHATGPT_MODELS = [+ # GPT-5.2 models (supports none/low/medium/high/xhigh reasoning)+ {"name": "gpt-5.2", "context_window": 272000},+ {"name": "gpt-5.2-codex", "context_window": 272000},+ # GPT-5.1 models+ {"name": "gpt-5.1", "context_window": 272000},+ {"name": "gpt-5.1-codex", "context_window": 272000},+ {"name": "gpt-5.1-codex-mini", "context_window": 272000},+ {"name": "gpt-5.1-codex-max", "context_window": 272000},+ # GPT-5 Codex models (original)+ {"name": "gpt-5-codex-mini", "context_window": 272000},+ # GPT-4 models (for ChatGPT Plus users)+ {"name": "gpt-4o", "context_window": 128000},+ {"name": "gpt-4o-mini", "context_window": 128000},+ {"name": "o1", "context_window": 200000},+ {"name": "o1-pro", "context_window": 200000},+ {"name": "o3", "context_window": 200000},+ {"name": "o3-mini", "context_window": 200000},+ {"name": "o4-mini", "context_window": 200000},+]+++class ChatGPTOAuthCredentials(BaseModel):+ """OAuth credentials for ChatGPT backend API access.++ These credentials are stored as JSON in the provider's api_key_enc field.+ """++ access_token: str = Field(..., description="OAuth access token for ChatGPT API")+ refresh_token: str = Field(..., description="OAuth refresh token for obtaining new access tokens")+ account_id: str = Field(..., description="ChatGPT account ID for the ChatGPT-Account-Id header")+ expires_at: int = Field(..., description="Unix timestamp when the access_token expires")++ def is_expired(self, buffer_seconds: int = TOKEN_REFRESH_BUFFER_SECONDS) -> bool:+ """Check if token is expired or will expire within buffer_seconds.++ Handles both seconds and milliseconds timestamps (auto-detects based on magnitude).+ """+ expires_at = self.expires_at+ # Auto-detect milliseconds (13+ digits) vs seconds (10 digits)+ # Timestamps > 10^12 are definitely milliseconds (year 33658 in seconds)+ if expires_at > 10**12:+ expires_at = expires_at // 1000 # Convert ms to seconds++ current_time = datetime.utcnow().timestamp()+ is_expired = current_time >= (expires_at - buffer_seconds)+ logger.debug(f"Token expiry check: current={current_time}, expires_at={expires_at}, buffer={buffer_seconds}, expired={is_expired}")+ return is_expired++ def to_json(self) -> str:+ """Serialize to JSON string for storage in api_key_enc."""+ return self.model_dump_json()++ @classmethod+ def from_json(cls, json_str: str) -> "ChatGPTOAuthCredentials":+ """Deserialize from JSON string stored in api_key_enc."""+ data = json.loads(json_str)+ return cls(**data)+++class ChatGPTOAuthProvider(Provider):+ """+ ChatGPT OAuth Provider for accessing ChatGPT's backend-api with OAuth tokens.++ This provider enables using ChatGPT Plus/Pro subscription credentials to access+ OpenAI models through the ChatGPT backend API at chatgpt.com/backend-api/codex.++ OAuth credentials are stored as JSON in the api_key_enc field:+ {+ "access_token": "...",+ "refresh_token": "...",+ "account_id": "...",+ "expires_at": 1234567890+ }++ The client (e.g., Letta Code) performs the OAuth flow and sends the credentials+ to the backend via the provider creation API.+ """++ provider_type: Literal[ProviderType.chatgpt_oauth] = Field(+ ProviderType.chatgpt_oauth,+ description="The type of the provider.",+ )+ provider_category: ProviderCategory = Field(+ ProviderCategory.byok, # Always BYOK since it uses user's OAuth credentials+ description="The category of the provider (always byok for OAuth)",+ )+ base_url: str = Field(+ CHATGPT_CODEX_ENDPOINT,+ description="Base URL for the ChatGPT backend API.",+ )++ async def get_oauth_credentials(self) -> Optional[ChatGPTOAuthCredentials]:+ """Retrieve and parse OAuth credentials from api_key_enc.++ Returns:+ ChatGPTOAuthCredentials if valid credentials exist, None otherwise.+ """+ if not self.api_key_enc:+ return None++ json_str = await self.api_key_enc.get_plaintext_async()+ if not json_str:+ return None++ try:+ return ChatGPTOAuthCredentials.from_json(json_str)+ except (json.JSONDecodeError, ValueError) as e:+ logger.error(f"Failed to parse ChatGPT OAuth credentials: {e}")+ return None++ async def refresh_token_if_needed(+ self, actor: Optional["User"] = None, force_refresh: bool = False+ ) -> Optional[ChatGPTOAuthCredentials]:+ """Check if token needs refresh and refresh if necessary.++ This method is called before each API request to ensure valid credentials.+ Tokens are refreshed 5 minutes before expiry to avoid edge cases.++ Args:+ actor: The user performing the action. Required for persisting refreshed credentials.+ force_refresh: If True, always refresh the token regardless of expiry. For testing only.++ Returns:+ Updated credentials if successful, None on failure.+ """+ creds = await self.get_oauth_credentials()+ if not creds:+ return None++ if not creds.is_expired() and not force_refresh:+ return creds++ # Token needs refresh+ logger.debug(f"ChatGPT OAuth token refresh triggered (expired={creds.is_expired()}, force={force_refresh})")++ try:+ new_creds = await self._perform_token_refresh(creds)+ # Update stored credentials in memory and persist to database+ await self._update_stored_credentials(new_creds, actor=actor)+ return new_creds+ except Exception as e:+ logger.error(f"Failed to refresh ChatGPT OAuth token: {e}")+ # If refresh fails but original access_token is still valid, use it+ if not creds.is_expired():+ logger.warning("Token refresh failed, but original access_token is still valid - using existing token")+ return creds+ # Both refresh failed AND token is expired - return None to trigger auth error+ return None++ async def _perform_token_refresh(self, creds: ChatGPTOAuthCredentials) -> ChatGPTOAuthCredentials:+ """Perform OAuth token refresh with OpenAI's token endpoint.++ Args:+ creds: Current credentials containing the refresh_token.++ Returns:+ New ChatGPTOAuthCredentials with refreshed access_token.++ Raises:+ LLMAuthenticationError: If refresh fails due to invalid credentials.+ LLMError: If refresh fails due to network or server error.+ """+ async with httpx.AsyncClient() as client:+ try:+ response = await client.post(+ CHATGPT_TOKEN_REFRESH_URL,+ data={+ "grant_type": "refresh_token",+ "refresh_token": creds.refresh_token,+ "client_id": CHATGPT_OAUTH_CLIENT_ID,+ },+ headers={+ "Content-Type": "application/x-www-form-urlencoded",+ },+ timeout=30.0,+ )+ response.raise_for_status()+ data = response.json()++ # Calculate new expiry time+ expires_in = data.get("expires_in", 3600)+ new_expires_at = int(datetime.utcnow().timestamp()) + expires_in++ new_access_token = data["access_token"]+ new_refresh_token = data.get("refresh_token", creds.refresh_token)++ logger.debug(f"ChatGPT OAuth token refreshed, expires_in={expires_in}s")++ return ChatGPTOAuthCredentials(+ access_token=new_access_token,+ refresh_token=new_refresh_token,+ account_id=creds.account_id, # Account ID doesn't change+ expires_at=new_expires_at,+ )+ except httpx.HTTPStatusError as e:+ # Log full error details for debugging+ try:+ error_body = e.response.json()+ logger.error(f"Token refresh HTTP error: {e.response.status_code} - JSON: {error_body}")+ except Exception:+ logger.error(f"Token refresh HTTP error: {e.response.status_code} - Text: {e.response.text}")+ if e.response.status_code == 401:+ raise LLMAuthenticationError(+ message="Failed to refresh ChatGPT OAuth token: refresh token is invalid or expired",+ code=ErrorCode.UNAUTHENTICATED,+ )+ raise LLMError(+ message=f"Failed to refresh ChatGPT OAuth token: {e}",+ code=ErrorCode.INTERNAL_SERVER_ERROR,+ )+ except Exception as e:+ logger.error(f"Token refresh error: {type(e).__name__}: {e}")+ raise LLMError(+ message=f"Failed to refresh ChatGPT OAuth token: {e}",+ code=ErrorCode.INTERNAL_SERVER_ERROR,+ )++ async def _update_stored_credentials(self, creds: ChatGPTOAuthCredentials, actor: Optional["User"] = None) -> None:+ """Update stored credentials in memory and persist to database.++ Args:+ creds: New credentials to store.+ actor: The user performing the action. Required for database persistence.+ """+ new_secret = await Secret.from_plaintext_async(creds.to_json())+ # Update in-memory value+ object.__setattr__(self, "api_key_enc", new_secret)++ # Persist to database if we have an actor and provider ID+ if actor and self.id:+ try:+ from letta.schemas.providers.base import ProviderUpdate+ from letta.services.provider_manager import ProviderManager++ provider_manager = ProviderManager()+ await provider_manager.update_provider_async(+ provider_id=self.id,+ provider_update=ProviderUpdate(api_key=creds.to_json()),+ actor=actor,+ )+ except Exception as e:+ logger.error(f"Failed to persist refreshed credentials to database: {e}")+ # Don't fail the request - we have valid credentials in memory++ async def check_api_key(self):+ """Validate the OAuth credentials by checking token validity.++ Raises:+ ValueError: If no credentials are configured.+ LLMAuthenticationError: If credentials are invalid.+ """+ creds = await self.get_oauth_credentials()+ if not creds:+ raise ValueError("No ChatGPT OAuth credentials configured")++ # Try to refresh if needed+ creds = await self.refresh_token_if_needed()+ if not creds:+ raise LLMAuthenticationError(+ message="Failed to obtain valid ChatGPT OAuth credentials",+ code=ErrorCode.UNAUTHENTICATED,+ )++ # Optionally make a test request to validate+ # For now, we just verify we have valid-looking credentials+ if not creds.access_token or not creds.account_id:+ raise LLMAuthenticationError(+ message="ChatGPT OAuth credentials are incomplete",+ code=ErrorCode.UNAUTHENTICATED,+ )++ def get_default_max_output_tokens(self, model_name: str) -> int:+ """Get the default max output tokens for ChatGPT models."""+ # Reasoning models (o-series) have higher limits+ if model_name.startswith("o1") or model_name.startswith("o3") or model_name.startswith("o4"):+ return 100000+ # GPT-5.x models+ elif "gpt-5" in model_name:+ return 16384+ # GPT-4 models+ elif "gpt-4" in model_name:+ return 16384+ return 4096++ async def list_llm_models_async(self) -> list[LLMConfig]:+ """List available models from ChatGPT backend.++ Returns a hardcoded list of models available via ChatGPT Plus/Pro subscriptions.+ """+ creds = await self.get_oauth_credentials()+ if not creds:+ logger.warning("Cannot list models: no valid ChatGPT OAuth credentials")+ return []++ configs = []+ for model in CHATGPT_MODELS:+ model_name = model["name"]+ context_window = model["context_window"]++ configs.append(+ LLMConfig(+ model=model_name,+ model_endpoint_type="chatgpt_oauth",+ model_endpoint=self.base_url,+ context_window=context_window,+ handle=self.get_handle(model_name),+ max_tokens=self.get_default_max_output_tokens(model_name),+ provider_name=self.name,+ provider_category=self.provider_category,+ )+ )++ return configs++ async def list_embedding_models_async(self) -> list:+ """ChatGPT backend does not support embedding models."""+ return []++ def get_model_context_window(self, model_name: str) -> int | None:+ """Get the context window for a model."""+ for model in CHATGPT_MODELS:+ if model["name"] == model_name:+ return model["context_window"]+ return 128000 # Default++ async def get_model_context_window_async(self, model_name: str) -> int | None:+ """Get the context window for a model (async version)."""+ return self.get_model_context_window(model_name)diff --git a/letta/server/rest_api/routers/v1/agents.py b/letta/server/rest_api/routers/v1/agents.pyindex f8fbcbc9f..509fd0882 100644--- a/letta/server/rest_api/routers/v1/agents.py+++ b/letta/server/rest_api/routers/v1/agents.py@@ -1542,6 +1542,7 @@ async def send_message("zai","groq","deepseek",+ "chatgpt_oauth",]# Create a new run for execution tracking@@ -2126,6 +2127,7 @@ async def preview_model_request("zai","groq","deepseek",+ "chatgpt_oauth",]if agent_eligible and model_compatible:@@ -2180,6 +2182,7 @@ async def summarize_messages("zai","groq","deepseek",+ "chatgpt_oauth",]if agent_eligible and model_compatible:diff --git a/letta/server/server.py b/letta/server/server.pyindex 82527bf2e..196c35f84 100644--- a/letta/server/server.py+++ b/letta/server/server.py@@ -1693,7 +1693,7 @@ class SyncServer(object):# TODO: cleanup this logicllm_config = letta_agent.agent_state.llm_config# supports_token_streaming = ["openai", "anthropic", "xai", "deepseek"]- supports_token_streaming = ["openai", "anthropic", "deepseek"] # TODO re-enable xAI once streaming is patched+ supports_token_streaming = ["openai", "anthropic", "deepseek", "chatgpt_oauth"] # TODO re-enable xAI once streaming is patchedif stream_tokens and (llm_config.model_endpoint_type not in supports_token_streaming):logger.warning(f"Token streaming is only supported for models with type {' or '.join(supports_token_streaming)} in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."@@ -1825,7 +1825,7 @@ class SyncServer(object):letta_multi_agent = load_multi_agent(group=group, agent_state=agent_state, actor=actor)llm_config = letta_multi_agent.agent_state.llm_config- supports_token_streaming = ["openai", "anthropic", "deepseek"]+ supports_token_streaming = ["openai", "anthropic", "deepseek", "chatgpt_oauth"]if stream_tokens and (llm_config.model_endpoint_type not in supports_token_streaming):logger.warning(f"Token streaming is only supported for models with type {' or '.join(supports_token_streaming)} in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."diff --git a/letta/services/provider_manager.py b/letta/services/provider_manager.pyindex 87fee46c3..bdf5e0e23 100644--- a/letta/services/provider_manager.py+++ b/letta/services/provider_manager.py@@ -482,6 +482,7 @@ class ProviderManager:try:# Get the provider class and create an instance+ from letta.schemas.enums import ProviderTypefrom letta.schemas.providers.anthropic import AnthropicProviderfrom letta.schemas.providers.azure import AzureProviderfrom letta.schemas.providers.bedrock import BedrockProvider@@ -491,42 +492,47 @@ class ProviderManager:from letta.schemas.providers.openai import OpenAIProviderfrom letta.schemas.providers.zai import ZAIProvider- provider_type_to_class = {- "openai": OpenAIProvider,- "anthropic": AnthropicProvider,- "groq": GroqProvider,- "google": GoogleAIProvider,- "ollama": OllamaProvider,- "bedrock": BedrockProvider,- "azure": AzureProvider,- "zai": ZAIProvider,- }-- provider_type = provider.provider_type.value if hasattr(provider.provider_type, "value") else str(provider.provider_type)- provider_class = provider_type_to_class.get(provider_type)-- if not provider_class:- logger.warning(f"No provider class found for type '{provider_type}'")- return-- # Create provider instance with necessary parameters- api_key = await provider.api_key_enc.get_plaintext_async() if provider.api_key_enc else None- access_key = await provider.access_key_enc.get_plaintext_async() if provider.access_key_enc else None- kwargs = {- "name": provider.name,- "api_key": api_key,- "provider_category": provider.provider_category,- }- if provider.base_url:- kwargs["base_url"] = provider.base_url- if access_key:- kwargs["access_key"] = access_key- if provider.region:- kwargs["region"] = provider.region- if provider.api_version:- kwargs["api_version"] = provider.api_version-- provider_instance = provider_class(**kwargs)+ # ChatGPT OAuth requires cast_to_subtype to preserve api_key_enc and id+ # (needed for OAuth token refresh and database persistence)+ if provider.provider_type == ProviderType.chatgpt_oauth:+ provider_instance = provider.cast_to_subtype()+ else:+ provider_type_to_class = {+ "openai": OpenAIProvider,+ "anthropic": AnthropicProvider,+ "groq": GroqProvider,+ "google": GoogleAIProvider,+ "ollama": OllamaProvider,+ "bedrock": BedrockProvider,+ "azure": AzureProvider,+ "zai": ZAIProvider,+ }++ provider_type = provider.provider_type.value if hasattr(provider.provider_type, "value") else str(provider.provider_type)+ provider_class = provider_type_to_class.get(provider_type)++ if not provider_class:+ logger.warning(f"No provider class found for type '{provider_type}'")+ return++ # Create provider instance with necessary parameters+ api_key = await provider.api_key_enc.get_plaintext_async() if provider.api_key_enc else None+ access_key = await provider.access_key_enc.get_plaintext_async() if provider.access_key_enc else None+ kwargs = {+ "name": provider.name,+ "api_key": api_key,+ "provider_category": provider.provider_category,+ }+ if provider.base_url:+ kwargs["base_url"] = provider.base_url+ if access_key:+ kwargs["access_key"] = access_key+ if provider.region:+ kwargs["region"] = provider.region+ if provider.api_version:+ kwargs["api_version"] = provider.api_version++ provider_instance = provider_class(**kwargs)# Query the provider's API for available modelsllm_models = await provider_instance.list_llm_models_async()diff --git a/letta/services/streaming_service.py b/letta/services/streaming_service.pyindex 79d466736..313b0d5f5 100644--- a/letta/services/streaming_service.py+++ b/letta/services/streaming_service.py@@ -493,11 +493,12 @@ class StreamingService:"zai","groq","deepseek",+ "chatgpt_oauth",]def _is_token_streaming_compatible(self, agent: AgentState) -> bool:"""Check if agent's model supports token-level streaming."""- base_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "bedrock", "deepseek", "zai"]+ base_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "bedrock", "deepseek", "zai", "chatgpt_oauth"]google_letta_v1 = agent.agent_type == AgentType.letta_v1_agent and agent.llm_config.model_endpoint_type in ["google_ai","google_vertex",