Codex Adapter

1
import asyncio
2
import logging
3
import os
4
from dotenv import load_dotenv
5
from band import Agent
6
from band.adapters import CodexAdapter, CodexAdapterConfig
7
from band.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("BAND_WS_URL"),
31
        rest_url=os.getenv("BAND_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
        # Communication style, maps to Codex personalization settings
10
        # See: https://developers.openai.com/codex/app/settings/#personalization
11
        # Options: "friendly", "pragmatic", or "none"
12
        personality="pragmatic",
13
14
        # Working directory for Codex execution
15
        cwd="/path/to/workspace",
16
17
        # Custom instructions appended to the system prompt
18
        custom_section="You are a helpful assistant.",
19
20
        # Reasoning control
21
        reasoning_effort="medium",       # none, minimal, low, medium, high, xhigh
22
        reasoning_summary="concise",     # auto, concise, detailed, none
23
24
        # Approval handling
25
        approval_policy="never",                   # Codex-level approval policy
26
        approval_mode="manual",                    # manual, auto_accept, auto_decline
27
        approval_wait_timeout_s=300.0,             # Seconds to wait for manual approval
28
        approval_timeout_decision="decline",       # Default decision on timeout
29
        approval_text_notifications=True,          # Send approval prompts to chat
30
31
        # Codex app-server sandbox mode. Applied at both thread creation
32
        # (as SandboxMode) and each turn (converted to sandboxPolicy).
33
        # Options: read-only, workspace-write, danger-full-access,
34
        # external-sandbox (external-sandbox is turn-level only)
35
        sandbox="external-sandbox",
36
37
        # Full sandbox policy dict. Applied at both thread creation and
38
        # each turn. Takes precedence over `sandbox` when set. Accepts a
39
        # "type" key (readOnly, workspaceWrite, dangerFullAccess,
40
        # externalSandbox) plus optional extra fields forwarded to Codex.
41
        sandbox_policy={"type": "workspaceWrite"},
42
43
        # Emit task events at the start and end of each Codex turn
44
        # (requires Emit.TASK_EVENTS in the adapter's features)
45
        emit_turn_task_markers=False,
46
47
        # Register LLM-callable tools that let Codex adjust its own
48
        # model and reasoning settings during a conversation
49
        enable_self_config_tools=False,
50
51
        # Maximum time for a single turn (seconds)
52
        turn_timeout_s=180.0,
53
54
        # --- Stdio transport options ---
55
56
        # Command to spawn the Codex CLI (auto-resolved from PATH if None)
57
        codex_command=None,
58
59
        # Extra environment variables merged with os.environ when spawning Codex
60
        codex_env=None,
61
62
        # WebSocket URL when transport is "ws"
63
        codex_ws_url="ws://127.0.0.1:8765",
64
65
        # --- Client identity reported to the Codex server ---
66
67
        client_name="band_codex_adapter",
68
        client_title="Band Codex Adapter",
69
        client_version="0.1.0",
70
    )
71
)

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
from band import AdapterFeatures, Emit
2
from band.adapters import CodexAdapter, CodexAdapterConfig
3
4
adapter = CodexAdapter(
5
    config=CodexAdapterConfig(transport="stdio"),
6
    features=AdapterFeatures(emit={Emit.EXECUTION, Emit.THOUGHTS}),
7
)

1
import asyncio
2
import logging
3
import os
4
from dotenv import load_dotenv
5
from band import Agent, AdapterFeatures, Emit
6
from band.adapters import CodexAdapter, CodexAdapterConfig
7
from band.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
        ),
33
        features=AdapterFeatures(emit={Emit.EXECUTION, Emit.TASK_EVENTS}),
34
    )
35
36
    agent = Agent.create(
37
        adapter=adapter,
38
        agent_id=agent_id,
39
        api_key=api_key,
40
        ws_url=os.getenv("BAND_WS_URL"),
41
        rest_url=os.getenv("BAND_REST_URL"),
42
    )
43
44
    logger.info("Codex agent is running! Press Ctrl+C to stop.")
45
    await agent.run()
46
47
if __name__ == "__main__":
48
    asyncio.run(main())

1
import asyncio
2
import os
3
import logging
4
from dotenv import load_dotenv
5
from band import Agent
6
from band.adapters import CodexAdapter, CodexAdapterConfig
7
from band.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("band").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("BAND_WS_URL"),
33
        rest_url=os.getenv("BAND_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())