OAuth Providers

ProviderSpec(
    name="openai_codex",
    keywords=("openai_codex", "codex", "gpt-5"),
    env_key="",                         # OAuth-based, no API key
    display_name="OpenAI Codex",
    litellm_prefix="openai-codex",     # model → openai-codex/model
    skip_prefixes=("openai-codex/", "openai_codex/"),
    env_extras=(),
    is_gateway=False,
    is_oauth=True,                      # OAuth-based authentication
)

ProviderSpec(
    name="github_copilot",
    keywords=("github_copilot", "copilot"),
    env_key="",                         # OAuth-based, no API key
    display_name="Github Copilot",
    litellm_prefix="github_copilot",   # github_copilot/model → github_copilot/model
    skip_prefixes=("github_copilot/",),
    env_extras=(),
    is_gateway=False,
    is_local=False,
    is_oauth=True,                      # OAuth-based authentication
)

class OpenAICodexProvider(LLMProvider):
    """Use Codex OAuth to call the Responses API."""
    
    def __init__(self, default_model: str = "openai-codex/gpt-5.1-codex"):
        super().__init__(api_key=None, api_base=None)
        self.default_model = default_model

token = await asyncio.to_thread(get_codex_token)
headers = _build_headers(token.account_id, token.access)

def _build_headers(account_id: str, token: str) -> dict[str, str]:
    return {
        "Authorization": f"Bearer {token}",
        "chatgpt-account-id": account_id,
        "OpenAI-Beta": "responses=experimental",
        "originator": DEFAULT_ORIGINATOR,
        "User-Agent": "nanobot (python)",
        "accept": "text/event-stream",
        "content-type": "application/json",
    }

DEFAULT_CODEX_URL = "https://chatgpt.com/backend-api/codex/responses"
DEFAULT_ORIGINATOR = "nanobot"

def _convert_messages(messages: list[dict[str, Any]]) -> tuple[str, list[dict[str, Any]]]:
    system_prompt = ""
    input_items: list[dict[str, Any]] = []
    
    for idx, msg in enumerate(messages):
        role = msg.get("role")
        content = msg.get("content")
        
        if role == "system":
            system_prompt = content if isinstance(content, str) else ""
            continue
        
        if role == "user":
            input_items.append(_convert_user_message(content))
            continue
        
        if role == "assistant":
            # Handle text first.
            if isinstance(content, str) and content:
                input_items.append(
                    {
                        "type": "message",
                        "role": "assistant",
                        "content": [{"type": "output_text", "text": content}],
                        "status": "completed",
                        "id": f"msg_{idx}",
                    }
                )
            # Then handle tool calls.
            for tool_call in msg.get("tool_calls", []) or []:
                fn = tool_call.get("function") or {}
                call_id, item_id = _split_tool_call_id(tool_call.get("id"))
                call_id = call_id or f"call_{idx}"
                item_id = item_id or f"fc_{idx}"
                input_items.append(
                    {
                        "type": "function_call",
                        "id": item_id,
                        "call_id": call_id,
                        "name": fn.get("name"),
                        "arguments": fn.get("arguments") or "{}",
                    }
                )
            continue
        
        if role == "tool":
            call_id, _ = _split_tool_call_id(msg.get("tool_call_id"))
            output_text = content if isinstance(content, str) else json.dumps(content, ensure_ascii=False)
            input_items.append(
                {
                    "type": "function_call_output",
                    "call_id": call_id,
                    "output": output_text,
                }
            )
            continue
    
    return system_prompt, input_items

def _prompt_cache_key(messages: list[dict[str, Any]]) -> str:
    raw = json.dumps(messages, ensure_ascii=True, sort_keys=True)
    return hashlib.sha256(raw.encode("utf-8")).hexdigest()

nanobot provider login openai-codex

nanobot provider login github-copilot

{
  "agents": {
    "defaults": {
      "model": "openai-codex/gpt-5.1-codex"
    }
  }
}

{
  "agents": {
    "defaults": {
      "model": "github_copilot/gpt-4"
    }
  }
}

# Interactive mode
nanobot agent

# Single message
nanobot agent -m "Explain OAuth flow"

# Login (requires interactive terminal)
docker run -it -v ~/.nanobot:/root/.nanobot nanobot provider login openai-codex

# Chat
docker run -it -v ~/.nanobot:/root/.nanobot nanobot agent

if reasoning_effort:
    body["reasoning"] = {"effort": reasoning_effort}

{
  "agents": {
    "defaults": {
      "model": "openai-codex/gpt-5.1-codex",
      "reasoningEffort": "high"
    }
  }
}

def _convert_tools(tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
    """Convert OpenAI function-calling schema to Codex flat format."""
    converted: list[dict[str, Any]] = []
    for tool in tools:
        fn = (tool.get("function") or {}) if tool.get("type") == "function" else tool
        name = fn.get("name")
        if not name:
            continue
        params = fn.get("parameters") or {}
        converted.append({
            "type": "function",
            "name": name,
            "description": fn.get("description") or "",
            "parameters": params if isinstance(params, dict) else {},
        })
    return converted

def _friendly_error(status_code: int, raw: str) -> str:
    if status_code == 429:
        return "ChatGPT usage quota exceeded or rate limit triggered. Please try again later."
    return f"HTTP {status_code}: {raw}"

try:
    content, tool_calls, finish_reason = await _request_codex(url, headers, body, verify=True)
except Exception as e:
    if "CERTIFICATE_VERIFY_FAILED" not in str(e):
        raise
    logger.warning("SSL certificate verification failed for Codex API; retrying with verify=False")
    content, tool_calls, finish_reason = await _request_codex(url, headers, body, verify=False)

nanobot provider login openai-codex

# Correct
docker run -it -v ~/.nanobot:/root/.nanobot nanobot provider login openai-codex

# Incorrect (will fail)
docker run -v ~/.nanobot:/root/.nanobot nanobot provider login openai-codex

{
  "agents": {
    "defaults": {
      "model": "gpt-5.1-codex"  // Auto-prefixed to "openai-codex/gpt-5.1-codex"
    }
  }
}

{
  "agents": {
    "defaults": {
      "model": "openai-codex/gpt-5.1-codex"
    }
  }
}