codex

codex

CodexAuthConfig module-attribute

CodexAuthConfig = (
    CodexAuth
    | Literal[
        "openai_oauth",
        "openai_api_key",
        "openai_api_key_env",
        "host_chatgpt",
        "none",
    ]
    | dict[str, Any]
    | None
)

AgentLike

instructions instance-attribute

instructions: str | None

mcp_servers instance-attribute

mcp_servers: list[Any]

name instance-attribute

name: str

permission instance-attribute

permission: Any

skills instance-attribute

skills: list[Any]

strict instance-attribute

strict: bool

Codex

approval_policy class-attribute instance-attribute

approval_policy: str | None = None

auth class-attribute instance-attribute

auth: CodexAuthConfig = None

extra_config class-attribute instance-attribute

extra_config: dict[str, Any] = Field(default_factory=dict)

features class-attribute instance-attribute

features: dict[str, bool] = Field(default_factory=dict)

id class-attribute instance-attribute

id: str = 'codex'

model class-attribute instance-attribute

model: str | None = None

model_provider class-attribute instance-attribute

model_provider: str | None = None

model_reasoning_effort class-attribute instance-attribute

model_reasoning_effort: str | None = None

model_reasoning_summary class-attribute instance-attribute

model_reasoning_summary: str | None = None

model_verbosity class-attribute instance-attribute

model_verbosity: str | None = None

sandbox_mode class-attribute instance-attribute

sandbox_mode: str | None = None

shell_environment_policy class-attribute instance-attribute

shell_environment_policy: dict[str, Any] = Field(
    default_factory=dict
)

web_search class-attribute instance-attribute

web_search: str | None = None

command

command(
    prompt: str, run_config: Any | None = None
) -> list[str]

materialise

materialise(
    ctx: MaterialiseContext, agent: AgentLike
) -> None

CodexAuth

env_var class-attribute instance-attribute

env_var: str | None = None

method instance-attribute

method: Literal[
    "openai_oauth",
    "openai_api_key_env",
    "host_chatgpt",
    "none",
]

refresh class-attribute instance-attribute

refresh: bool = False

service class-attribute instance-attribute

service: str = 'openai'

host_chatgpt classmethod

host_chatgpt() -> CodexAuth

none classmethod

none() -> CodexAuth

openai_api_key_env classmethod

openai_api_key_env(
    env_var: str = "OPENAI_API_KEY",
    *,
    service: str = "openai",
) -> CodexAuth

openai_oauth classmethod

openai_oauth(*, refresh: bool = False) -> CodexAuth

MaterialiseContext

metadata class-attribute instance-attribute

metadata: dict[str, Any] = Field(default_factory=dict)

model_config class-attribute instance-attribute

model_config = ConfigDict(arbitrary_types_allowed=True)

sandbox instance-attribute

sandbox: Any

workspace instance-attribute

workspace: Path

_codex_approval_policy

_codex_approval_policy(default: str | None) -> str | None

render_codex_mcp_servers

render_codex_mcp_servers(
    servers: list[MCPServer],
) -> dict[str, Any]

render_toml

render_toml(data: dict[str, Any]) -> str

write_instructions

write_instructions(
    workspace: Path,
    instructions: str | None,
    skills: list[Skill],
) -> None

write_skills

write_skills(
    skills: list[Skill],
    destination: Path,
    *,
    frontmatter: bool = False,
) -> None