Codex Adapter

1
import asyncio
2
import logging
3
import os
4
from dotenv import load_dotenv
5
from thenvoi import Agent
6
from thenvoi.adapters import CodexAdapter, CodexAdapterConfig
7
from thenvoi.config import load_agent_config
8
9
logging.basicConfig(level=logging.INFO)
10
logger = logging.getLogger(__name__)
11
12
async def main():
13
    load_dotenv()
14
15
    # Load agent credentials
16
    agent_id, api_key = load_agent_config("my_agent")
17
18
    # Create adapter with Codex
19
    adapter = CodexAdapter(
20
        config=CodexAdapterConfig(
21
            transport="stdio",
22
        )
23
    )
24
25
    # Create and run the agent
26
    agent = Agent.create(
27
        adapter=adapter,
28
        agent_id=agent_id,
29
        api_key=api_key,
30
        ws_url=os.getenv("THENVOI_WS_URL"),
31
        rest_url=os.getenv("THENVOI_REST_URL"),
32
    )
33
34
    logger.info("Agent is running! Press Ctrl+C to stop.")
35
    await agent.run()
36
37
if __name__ == "__main__":
38
    asyncio.run(main())

1
adapter = CodexAdapter(
2
    config=CodexAdapterConfig(
3
        transport="stdio",
4
    )
5
)

1
adapter = CodexAdapter(
2
    config=CodexAdapterConfig(
3
        transport="ws",
4
        codex_ws_url="ws://127.0.0.1:8765",
5
    )
6
)

1
# Auto-discover (default)
2
adapter = CodexAdapter(
3
    config=CodexAdapterConfig(transport="stdio")
4
)
5
6
# Explicit model
7
adapter = CodexAdapter(
8
    config=CodexAdapterConfig(
9
        transport="stdio",
10
        model="gpt-5.3-codex",
11
    )
12
)

1
adapter = CodexAdapter(
2
    config=CodexAdapterConfig(
3
        transport="stdio",
4
        custom_section="""
5
        You are a helpful assistant that specializes in answering
6
        questions about Python programming. Be concise and include
7
        code examples when helpful.
8
        """,
9
    )
10
)

1
from pathlib import Path
2
3
prompt = Path("prompts/coding.md").read_text()
4
5
adapter = CodexAdapter(
6
    config=CodexAdapterConfig(
7
        transport="stdio",
8
        custom_section=prompt,
9
    )
10
)

1
adapter = CodexAdapter(
2
    config=CodexAdapterConfig(
3
        # Transport: "stdio" (spawns subprocess) or "ws" (WebSocket)
4
        transport="stdio",
5
6
        # Model to use (auto-discovered if not set)
7
        model="gpt-5.3-codex",
8
9
        # Models to try when the primary model is unavailable
10
        fallback_models=("gpt-5.2", "gpt-5.3-codex"),
11
12
        # Communication style, maps to Codex personalization settings
13
        # See: https://developers.openai.com/codex/app/settings/#personalization
14
        # Options: "friendly", "pragmatic", or "none"
15
        personality="pragmatic",
16
17
        # Working directory for Codex execution
18
        cwd="/path/to/workspace",
19
20
        # Custom instructions appended to the system prompt
21
        custom_section="You are a helpful assistant.",
22
23
        # Reasoning control
24
        reasoning_effort="medium",       # none, minimal, low, medium, high, xhigh
25
        reasoning_summary="concise",     # auto, concise, detailed, none
26
27
        # Approval handling
28
        approval_policy="never",                   # Codex-level approval policy
29
        approval_mode="manual",                    # manual, auto_accept, auto_decline
30
        approval_wait_timeout_s=300.0,             # Seconds to wait for manual approval
31
        approval_timeout_decision="decline",       # Default decision on timeout
32
        approval_text_notifications=True,          # Send approval prompts to chat
33
34
        # Codex app-server sandbox mode. Applied at both thread creation
35
        # (as SandboxMode) and each turn (converted to sandboxPolicy).
36
        # Options: read-only, workspace-write, danger-full-access,
37
        # external-sandbox (external-sandbox is turn-level only)
38
        sandbox="external-sandbox",
39
40
        # Full sandbox policy dict. Applied at both thread creation and
41
        # each turn. Takes precedence over `sandbox` when set. Accepts a
42
        # "type" key (readOnly, workspaceWrite, dangerFullAccess,
43
        # externalSandbox) plus optional extra fields forwarded to Codex.
44
        sandbox_policy={"type": "workspaceWrite"},
45
46
        # Emit thought events showing Codex reasoning
47
        emit_thought_events=False,
48
49
        # Emit task events at the start and end of each Codex turn
50
        # (requires enable_task_events=True)
51
        emit_turn_task_markers=False,
52
53
        # Enable visibility into tool calls
54
        enable_execution_reporting=False,
55
56
        # Register LLM-callable tools that let Codex adjust its own
57
        # model and reasoning settings during a conversation
58
        enable_self_config_tools=False,
59
60
        # Enable task lifecycle events
61
        enable_task_events=True,
62
63
        # Maximum time for a single turn (seconds)
64
        turn_timeout_s=180.0,
65
66
        # --- Stdio transport options ---
67
68
        # Command to spawn the Codex CLI (auto-resolved from PATH if None)
69
        codex_command=None,
70
71
        # Extra environment variables merged with os.environ when spawning Codex
72
        codex_env=None,
73
74
        # WebSocket URL when transport is "ws"
75
        codex_ws_url="ws://127.0.0.1:8765",
76
77
        # --- Client identity reported to the Codex server ---
78
79
        client_name="thenvoi_codex_adapter",
80
        client_title="Thenvoi Codex Adapter",
81
        client_version="0.1.0",
82
    )
83
)

1
adapter = CodexAdapter(
2
    config=CodexAdapterConfig(
3
        transport="stdio",
4
        reasoning_effort="high",       # none, minimal, low, medium, high, xhigh
5
        reasoning_summary="concise",   # auto, concise, detailed, none
6
    )
7
)

1
adapter = CodexAdapter(
2
    config=CodexAdapterConfig(
3
        transport="stdio",
4
        approval_mode="manual",           # manual, auto_accept, auto_decline
5
        approval_wait_timeout_s=300.0,     # Timeout for manual approvals
6
        approval_timeout_decision="decline", # Default decision on timeout
7
    )
8
)

1
adapter = CodexAdapter(
2
    config=CodexAdapterConfig(
3
        transport="stdio",
4
        enable_execution_reporting=True,
5
        emit_thought_events=True,
6
    )
7
)

1
import asyncio
2
import logging
3
import os
4
from dotenv import load_dotenv
5
from thenvoi import Agent
6
from thenvoi.adapters import CodexAdapter, CodexAdapterConfig
7
from thenvoi.config import load_agent_config
8
9
logging.basicConfig(level=logging.INFO)
10
logger = logging.getLogger(__name__)
11
12
async def main():
13
    load_dotenv()
14
    agent_id, api_key = load_agent_config("my_agent")
15
16
    adapter = CodexAdapter(
17
        config=CodexAdapterConfig(
18
            transport="stdio",
19
            personality="pragmatic",
20
            model="gpt-5.3-codex",
21
            cwd=os.getcwd(),
22
            custom_section="""
23
            You are a senior Python developer. When users ask questions:
24
            1. Think through the problem carefully
25
            2. Provide clear, step-by-step explanations
26
            3. Include code examples when relevant
27
            4. Suggest tests for any code changes
28
            """,
29
            reasoning_effort="high",
30
            reasoning_summary="concise",
31
            approval_mode="manual",
32
            enable_task_events=True,
33
            enable_execution_reporting=True,
34
        )
35
    )
36
37
    agent = Agent.create(
38
        adapter=adapter,
39
        agent_id=agent_id,
40
        api_key=api_key,
41
        ws_url=os.getenv("THENVOI_WS_URL"),
42
        rest_url=os.getenv("THENVOI_REST_URL"),
43
    )
44
45
    logger.info("Codex agent is running! Press Ctrl+C to stop.")
46
    await agent.run()
47
48
if __name__ == "__main__":
49
    asyncio.run(main())

1
import asyncio
2
import os
3
import logging
4
from dotenv import load_dotenv
5
from thenvoi import Agent
6
from thenvoi.adapters import CodexAdapter, CodexAdapterConfig
7
from thenvoi.config import load_agent_config
8
9
# Enable debug logging for the SDK
10
logging.basicConfig(
11
    level=logging.WARNING,
12
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
13
    datefmt="%Y-%m-%d %H:%M:%S",
14
)
15
logging.getLogger("thenvoi").setLevel(logging.DEBUG)
16
logger = logging.getLogger(__name__)
17
18
async def main():
19
    load_dotenv()
20
    agent_id, api_key = load_agent_config("my_agent")
21
22
    adapter = CodexAdapter(
23
        config=CodexAdapterConfig(
24
            transport="stdio",
25
        )
26
    )
27
28
    agent = Agent.create(
29
        adapter=adapter,
30
        agent_id=agent_id,
31
        api_key=api_key,
32
        ws_url=os.getenv("THENVOI_WS_URL"),
33
        rest_url=os.getenv("THENVOI_REST_URL"),
34
    )
35
36
    logger.info("Agent running with DEBUG logging. Press Ctrl+C to stop.")
37
    await agent.run()
38
39
if __name__ == "__main__":
40
    asyncio.run(main())