codex-python 0.2.10__tar.gz → 0.2.11__tar.gz

{codex_python-0.2.10 → codex_python-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-python
-Version: 0.2.10
+Version: 0.2.11
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.13

{codex_python-0.2.10 → codex_python-0.2.11}/codex/__init__.py

@@ -31,4 +31,4 @@ __all__ = [
 ]
 
 # Package version. Kept in sync with Cargo.toml via CI before builds.
-__version__ = "0.2.10"
+__version__ = "0.2.11"

codex_python-0.2.11/codex/config.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, cast
+
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+
+
+class ApprovalPolicy(str, Enum):
+    """Approval policy for executing shell commands.
+
+    Matches Rust enum `AskForApproval` (serde kebab-case):
+    - "untrusted": auto-approve safe read-only commands, ask otherwise
+    - "on-failure": sandbox by default; ask only if the sandboxed run fails
+    - "on-request": model decides (default)
+    - "never": never ask the user
+    """
+
+    UNTRUSTED = "untrusted"
+    ON_FAILURE = "on-failure"
+    ON_REQUEST = "on-request"
+    NEVER = "never"
+
+
+class SandboxMode(str, Enum):
+    """High-level sandbox mode override.
+
+    Matches Rust enum `SandboxMode` (serde kebab-case):
+    - "read-only"
+    - "workspace-write"
+    - "danger-full-access"
+    """
+
+    READ_ONLY = "read-only"
+    WORKSPACE_WRITE = "workspace-write"
+    DANGER_FULL_ACCESS = "danger-full-access"
+
+
+class HistoryPersistence(str, Enum):
+    SAVE_ALL = "save-all"
+    NONE = "none"
+
+
+class HistoryConfig(BaseModel):
+    persistence: HistoryPersistence | None = None
+    max_bytes: int | None = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+class SandboxWorkspaceWrite(BaseModel):
+    writable_roots: list[str] | None = None
+    network_access: bool | None = None
+    exclude_tmpdir_env_var: bool | None = None
+    exclude_slash_tmp: bool | None = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+class McpServerConfig(BaseModel):
+    command: str
+    args: list[str] | None = None
+    env: dict[str, str] | None = None
+    startup_timeout_ms: int | None = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+class WireApi(str, Enum):
+    CHAT = "chat"
+    RESPONSES = "responses"
+
+
+class ModelProviderConfig(BaseModel):
+    name: str | None = None
+    base_url: str | None = None
+    env_key: str | None = None
+    wire_api: WireApi | None = None
+    query_params: dict[str, str] | None = None
+    http_headers: dict[str, str] | None = None
+    env_http_headers: dict[str, str] | None = None
+    request_max_retries: int | None = None
+    stream_max_retries: int | None = None
+    stream_idle_timeout_ms: int | None = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+class FileOpener(str, Enum):
+    VSCODE = "vscode"
+    VSCODE_INSIDERS = "vscode-insiders"
+    WINDSURF = "windsurf"
+    CURSOR = "cursor"
+    NONE = "none"
+
+
+class ReasoningEffort(str, Enum):
+    MINIMAL = "minimal"
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class ReasoningSummary(str, Enum):
+    AUTO = "auto"
+    CONCISE = "concise"
+    DETAILED = "detailed"
+    NONE = "none"
+
+
+class ReasoningSummaryFormat(str, Enum):
+    NONE = "none"
+    EXPERIMENTAL = "experimental"
+
+
+class Verbosity(str, Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class ToolsConfig(BaseModel):
+    # Accept either "web_search" or legacy alias "web_search_request" on input
+    web_search: bool | None = Field(
+        default=None, validation_alias=AliasChoices("web_search", "web_search_request")
+    )
+    # Also expose view_image knob (defaults handled in Rust)
+    view_image: bool | None = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+class ProfileConfig(BaseModel):
+    model: str | None = None
+    model_provider: str | None = None
+    approval_policy: ApprovalPolicy | None = None
+    model_reasoning_effort: ReasoningEffort | None = None
+    model_reasoning_summary: ReasoningSummary | None = None
+    model_verbosity: Verbosity | None = None
+    chatgpt_base_url: str | None = None
+    experimental_instructions_file: str | None = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+class ProjectConfig(BaseModel):
+    trust_level: str | None = Field(
+        default=None, description='Only "trusted" is recognized by the core.'
+    )
+
+    model_config = ConfigDict(extra="allow")
+
+
+class PreferredAuthMethod(str, Enum):
+    CHATGPT = "chatgpt"
+    APIKEY = "apikey"
+
+
+class CodexConfig(BaseModel):
+    """Configuration overrides for Codex.
+
+    This mirrors `codex_core::config::ConfigOverrides` and is intentionally
+    conservative: only values present (not None) are passed to the native core.
+    """
+
+    # Model selection
+    model: str | None = Field(default=None, description="Model slug, e.g. 'gpt-5' or 'o3'.")
+    model_provider: str | None = Field(
+        default=None, description="Provider key from config, e.g. 'openai'."
+    )
+
+    # Safety/Execution
+    approval_policy: ApprovalPolicy | None = Field(default=None)
+    sandbox_mode: SandboxMode | None = Field(default=None)
+    sandbox_workspace_write: SandboxWorkspaceWrite | None = None
+
+    # Environment
+    cwd: str | None = Field(default=None, description="Working directory for the session.")
+    config_profile: str | None = Field(
+        default=None, description="Config profile key to use (from profiles.*)."
+    )
+    codex_linux_sandbox_exe: str | None = Field(
+        default=None, description="Absolute path to codex-linux-sandbox (Linux only)."
+    )
+
+    # UX / features
+    base_instructions: str | None = Field(default=None, description="Override base instructions.")
+    include_plan_tool: bool | None = Field(default=None)
+    include_apply_patch_tool: bool | None = Field(default=None)
+    include_view_image_tool: bool | None = Field(default=None)
+    show_raw_agent_reasoning: bool | None = Field(default=None)
+
+    # Model/runtime tuning
+    model_context_window: int | None = None
+    model_max_output_tokens: int | None = None
+    model_reasoning_effort: ReasoningEffort | None = None
+    model_reasoning_summary: ReasoningSummary | None = None
+    model_verbosity: Verbosity | None = None
+    model_supports_reasoning_summaries: bool | None = None
+    model_reasoning_summary_format: ReasoningSummaryFormat | None = None
+
+    # Auth/UI options
+    hide_agent_reasoning: bool | None = None
+    chatgpt_base_url: str | None = None
+    preferred_auth_method: PreferredAuthMethod | None = None
+    file_opener: FileOpener | None = None
+
+    # Config file composed sections
+    history: HistoryConfig | None = None
+    tui: dict[str, Any] | None = None
+    notify: list[str] | None = None
+    instructions: str | None = Field(
+        default=None,
+        description="Ignored by core; prefer AGENTS.md or experimental_instructions_file.",
+    )
+    mcp_servers: dict[str, McpServerConfig] | None = None
+    model_providers: dict[str, ModelProviderConfig] | None = None
+    project_doc_max_bytes: int | None = None
+    profile: str | None = None
+    profiles: dict[str, ProfileConfig] | None = None
+    tools: ToolsConfig | None = None
+    projects: dict[str, ProjectConfig] | None = None
+
+    # Experimental / internal
+    experimental_resume: str | None = None
+    experimental_instructions_file: str | None = None
+    experimental_use_exec_command_tool: bool | None = None
+    responses_originator_header_internal_override: str | None = None
+    disable_response_storage: bool | None = Field(
+        default=None, description="Accepted in some clients; ignored by core."
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return overrides as a plain dict with None values removed.
+
+        Enum fields are emitted as their string values.
+        """
+        return cast(dict[str, Any], self.model_dump(exclude_none=True))
+
+    # Pydantic v2 config. `use_enum_values=True` ensures enums dump as strings.
+    # Place at end of class, extra='allow' per style.
+    model_config = ConfigDict(extra="allow", validate_assignment=True, use_enum_values=True)

{codex_python-0.2.10 → codex_python-0.2.11}/crates/codex_native/Cargo.lock

@@ -253,7 +253,7 @@ dependencies = [
 
 [[package]]
 name = "codex_native"
-version = "0.2.10"
+version = "0.2.11"
 dependencies = [
  "anyhow",
  "codex-core",

{codex_python-0.2.10 → codex_python-0.2.11}/crates/codex_native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "codex_native"
-version = "0.2.10"
+version = "0.2.11"
 edition = "2021"
 
 [lib]

{codex_python-0.2.10 → codex_python-0.2.11}/crates/codex_native/src/lib.rs

@@ -1,11 +1,15 @@
 use anyhow::{Context, Result};
-use codex_core::config::{find_codex_home, Config, ConfigOverrides, ConfigToml};
+use codex_core::config::{
+    find_codex_home, load_config_as_toml_with_cli_overrides, Config, ConfigOverrides, ConfigToml,
+};
 use codex_core::protocol::{EventMsg, InputItem};
 use codex_core::{AuthManager, ConversationManager};
 // use of SandboxMode is handled within core::config; not needed here
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyFloat, PyList, PyModule, PyString};
 use serde_json::Value as JsonValue;
+use toml::value::Value as TomlValue;
+use toml::value::Table as TomlTable;
 use std::path::PathBuf;
 use std::sync::{mpsc, Arc, Mutex};
 use std::thread;
@@ -173,7 +177,10 @@ fn build_config(
     load_default_config: bool,
 ) -> Result<Config> {
     let mut overrides_struct = ConfigOverrides::default();
+    let mut cli_overrides: Vec<(String, TomlValue)> = Vec::new();
+
     if let Some(dict) = overrides {
+        // Extract strongly-typed overrides first (these take precedence over CLI overrides).
         if let Some(model) = dict.get_item("model")? {
             overrides_struct.model = Some(model.extract()?);
         }
@@ -222,17 +229,124 @@ fn build_config(
         if let Some(v) = dict.get_item("tools_web_search_request")? {
             overrides_struct.tools_web_search_request = Some(v.extract()?);
         }
+
+        // Keys handled as strongly-typed above should not be duplicated in CLI overrides.
+        let typed_keys = [
+            "model",
+            "model_provider",
+            "config_profile",
+            "approval_policy",
+            "sandbox_mode",
+            "cwd",
+            "codex_linux_sandbox_exe",
+            "base_instructions",
+            "include_plan_tool",
+            "include_apply_patch_tool",
+            "include_view_image_tool",
+            "show_raw_agent_reasoning",
+            "tools_web_search_request",
+        ];
+
+        // Collect remaining extras and turn them into CLI-style dotted overrides.
+        for (key_obj, value_obj) in dict.iter() {
+            let key: String = match key_obj.extract() {
+                Ok(s) => s,
+                Err(_) => continue,
+            };
+            if typed_keys.contains(&key.as_str()) {
+                continue;
+            }
+
+            // Convert Python value -> TomlValue
+            let tv = match py_to_toml_value(value_obj)? {
+                Some(v) => v,
+                None => continue, // skip None/null values
+            };
+
+            if key.contains('.') {
+                // Already a dotted path: use as-is.
+                cli_overrides.push((key, tv));
+            } else {
+                // Flatten nested tables; otherwise add directly.
+                flatten_overrides(&mut cli_overrides, &key, tv);
+            }
+        }
     }
 
     if load_default_config {
-        Ok(Config::load_with_cli_overrides(vec![], overrides_struct)?)
+        Ok(Config::load_with_cli_overrides(cli_overrides, overrides_struct)?)
     } else {
         let codex_home = find_codex_home()?;
-        Ok(Config::load_from_base_config_with_overrides(
-            ConfigToml::default(),
-            overrides_struct,
-            codex_home,
-        )?)
+        let cfg = load_config_as_toml_with_cli_overrides(&codex_home, cli_overrides)?;
+        Ok(Config::load_from_base_config_with_overrides(cfg, overrides_struct, codex_home)?)
+    }
+}
+
+/// Convert a Python object into a TOML value. Returns Ok(None) for `None`.
+fn py_to_toml_value(obj: Bound<'_, PyAny>) -> Result<Option<TomlValue>> {
+    use pyo3::types::{PyBool, PyDict, PyFloat, PyInt, PyList, PyString};
+
+    if obj.is_none() {
+        return Ok(None);
+    }
+
+    if let Ok(b) = obj.downcast::<PyBool>() {
+        return Ok(Some(TomlValue::Boolean(b.is_true())));
+    }
+    if let Ok(i) = obj.downcast::<PyInt>() {
+        let v: i64 = i.extract()?;
+        return Ok(Some(TomlValue::Integer(v.into())));
+    }
+    if let Ok(f) = obj.downcast::<PyFloat>() {
+        let v: f64 = f.extract()?;
+        return Ok(Some(TomlValue::Float(v.into())));
+    }
+    if let Ok(s) = obj.downcast::<PyString>() {
+        let v: String = s.extract()?;
+        return Ok(Some(TomlValue::String(v.into())));
+    }
+    if let Ok(list) = obj.downcast::<PyList>() {
+        let mut arr = Vec::with_capacity(list.len());
+        for item in list.iter() {
+            if let Some(tv) = py_to_toml_value(item)? {
+                arr.push(tv);
+            }
+        }
+        return Ok(Some(TomlValue::Array(arr)));
+    }
+    if let Ok(map) = obj.downcast::<PyDict>() {
+        let mut tbl = TomlTable::new();
+        for (k_obj, v_obj) in map.iter() {
+            let key: String = match k_obj.extract() {
+                Ok(s) => s,
+                Err(_) => continue,
+            };
+            if let Some(tv) = py_to_toml_value(v_obj)? {
+                tbl.insert(key, tv);
+            }
+        }
+        return Ok(Some(TomlValue::Table(tbl)));
+    }
+
+    // Fallback: use `str(obj)`
+    let s = obj.str()?.to_string_lossy().to_string();
+    Ok(Some(TomlValue::String(s.into())))
+}
+
+/// Recursively flatten a TOML value into dotted overrides.
+fn flatten_overrides(out: &mut Vec<(String, TomlValue)>, prefix: &str, val: TomlValue) {
+    match val {
+        TomlValue::Table(tbl) => {
+            for (k, v) in tbl.into_iter() {
+                let key = if prefix.is_empty() {
+                    k
+                } else {
+                    format!("{prefix}.{k}")
+                };
+                flatten_overrides(out, &key, v);
+            }
+        }
+        other => out.push((prefix.to_string(), other)),
     }
 }
 

codex_python-0.2.10/codex/config.py

@@ -1,82 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Any, cast
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class ApprovalPolicy(str, Enum):
-    """Approval policy for executing shell commands.
-
-    Matches Rust enum `AskForApproval` (serde kebab-case):
-    - "untrusted": auto-approve safe read-only commands, ask otherwise
-    - "on-failure": sandbox by default; ask only if the sandboxed run fails
-    - "on-request": model decides (default)
-    - "never": never ask the user
-    """
-
-    UNTRUSTED = "untrusted"
-    ON_FAILURE = "on-failure"
-    ON_REQUEST = "on-request"
-    NEVER = "never"
-
-
-class SandboxMode(str, Enum):
-    """High-level sandbox mode override.
-
-    Matches Rust enum `SandboxMode` (serde kebab-case):
-    - "read-only"
-    - "workspace-write"
-    - "danger-full-access"
-    """
-
-    READ_ONLY = "read-only"
-    WORKSPACE_WRITE = "workspace-write"
-    DANGER_FULL_ACCESS = "danger-full-access"
-
-
-class CodexConfig(BaseModel):
-    """Configuration overrides for Codex.
-
-    This mirrors `codex_core::config::ConfigOverrides` and is intentionally
-    conservative: only values present (not None) are passed to the native core.
-    """
-
-    # Model selection
-    model: str | None = Field(default=None, description="Model slug, e.g. 'gpt-5' or 'o3'.")
-    model_provider: str | None = Field(
-        default=None, description="Provider key from config, e.g. 'openai'."
-    )
-
-    # Safety/Execution
-    approval_policy: ApprovalPolicy | None = Field(default=None)
-    sandbox_mode: SandboxMode | None = Field(default=None)
-
-    # Environment
-    cwd: str | None = Field(default=None, description="Working directory for the session.")
-    config_profile: str | None = Field(
-        default=None, description="Config profile key to use (from profiles.*)."
-    )
-    codex_linux_sandbox_exe: str | None = Field(
-        default=None, description="Absolute path to codex-linux-sandbox (Linux only)."
-    )
-
-    # UX / features
-    base_instructions: str | None = Field(default=None, description="Override base instructions.")
-    include_plan_tool: bool | None = Field(default=None)
-    include_apply_patch_tool: bool | None = Field(default=None)
-    include_view_image_tool: bool | None = Field(default=None)
-    show_raw_agent_reasoning: bool | None = Field(default=None)
-    tools_web_search_request: bool | None = Field(default=None)
-
-    def to_dict(self) -> dict[str, Any]:
-        """Return overrides as a plain dict with None values removed.
-
-        Enum fields are emitted as their string values.
-        """
-        return cast(dict[str, Any], self.model_dump(exclude_none=True))
-
-    # Pydantic v2 config. `use_enum_values=True` ensures enums dump as strings.
-    # Place at end of class, extra='allow' per style.
-    model_config = ConfigDict(extra="allow", validate_assignment=True, use_enum_values=True)