fix: don't load config file if not reequested

Author: gersmann

codex/__init__.py

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

codex/api.py

@@ -4,7 +4,7 @@
 from dataclasses import dataclass
 
 from .config import CodexConfig
-from .event import Event
+from .event import AnyEventMsg, Event
 from .native import run_exec_collect as native_run_exec_collect
 from .native import start_exec_stream as native_start_exec_stream
 
@@ -32,7 +32,15 @@ class Conversation:
     def __iter__(self) -> Iterator[Event]:
         """Yield `Event` objects from the native stream."""
         for item in self._stream:
-            yield Event.model_validate(item)
+            try:
+                yield Event.model_validate(item)
+            except Exception:
+                ev_id = item.get("id") if isinstance(item, dict) else None
+                msg_obj = item.get("msg") if isinstance(item, dict) else None
+                if isinstance(msg_obj, dict) and isinstance(msg_obj.get("type"), str):
+                    yield Event(id=ev_id or "unknown", msg=AnyEventMsg(**msg_obj))
+                else:
+                    yield Event(id=ev_id or "unknown", msg=AnyEventMsg(type="unknown"))
 
 
 @dataclass(slots=True)
@@ -88,6 +96,18 @@ def run_exec(
             config_overrides=config.to_dict() if config else None,
             load_default_config=load_default_config,
         )
-        return [Event.model_validate(e) for e in events]
     except RuntimeError as e:
         raise CodexNativeError() from e
+
+    out: list[Event] = []
+    for item in events:
+        try:
+            out.append(Event.model_validate(item))
+        except Exception:
+            ev_id = item.get("id") if isinstance(item, dict) else None
+            msg_obj = item.get("msg") if isinstance(item, dict) else None
+            if isinstance(msg_obj, dict) and isinstance(msg_obj.get("type"), str):
+                out.append(Event(id=ev_id or "unknown", msg=AnyEventMsg(**msg_obj)))
+            else:
+                out.append(Event(id=ev_id or "unknown", msg=AnyEventMsg(type="unknown")))
+    return out

codex/event.py

@@ -6,11 +6,24 @@
 from .protocol.types import EventMsg
 
 
+class AnyEventMsg(BaseModel):
+    """Fallback event payload that preserves the original `type` and fields.
+
+    Accepts any additional keys to retain upstream payloads when strict
+    validation fails for generated models.
+    """
+
+    type: str
+
+    # Allow arbitrary extra fields so we don't lose information
+    model_config = ConfigDict(extra="allow")
+
+
 class Event(BaseModel):
     """Protocol event envelope with typed `msg` (union of EventMsg_*)."""
 
     id: str
-    msg: EventMsg
+    msg: EventMsg | AnyEventMsg
 
     # Allow forward compatibility with additional envelope fields
     model_config = ConfigDict(extra="allow")

crates/codex_native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "codex_native"
-version = "0.2.12"
+version = "0.2.14"
 edition = "2021"
 
 [lib]
@@ -25,8 +25,8 @@ pathdiff = "0.2"
 
 # Upstream Codex crates from the monorepo (use git deps; pin to main for now)
 # Pin to a specific commit of the upstream Codex monorepo to avoid breaking API changes
-codex-core = { git = "https://github.com/openai/codex", package = "codex-core", rev = "c13c3dad" }
-codex-protocol = { git = "https://github.com/openai/codex", package = "codex-protocol", rev = "c13c3dad" }
+codex-core = { git = "https://github.com/openai/codex", package = "codex-core", branch = "main" }
+codex-protocol = { git = "https://github.com/openai/codex", package = "codex-protocol", branch = "main" }
 
 # Tell maturin to include the Python sources from the repo root (mixed project)
 [package.metadata.maturin]

crates/codex_native/src/lib.rs

@@ -1,7 +1,5 @@
 use anyhow::{Context, Result};
-use codex_core::config::{
-    find_codex_home, load_config_as_toml_with_cli_overrides, Config, ConfigOverrides, ConfigToml,
-};
+use codex_core::config::{find_codex_home, 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
@@ -42,7 +40,6 @@ fn run_exec_collect(
 async fn run_exec_impl(prompt: String, config: Config) -> Result<Vec<JsonValue>> {
     let conversation_manager = ConversationManager::new(AuthManager::shared(
         config.codex_home.clone(),
-        config.preferred_auth_method,
     ));
     let new_conv = conversation_manager.new_conversation(config).await?;
     let conversation = new_conv.conversation.clone();
@@ -274,10 +271,22 @@ fn build_config(
     }
 
     if load_default_config {
+        // Start from built-in defaults and apply CLI + typed overrides.
         Ok(Config::load_with_cli_overrides(cli_overrides, overrides_struct)?)
     } else {
+        // Do NOT read any on-disk config. Build a TOML value purely from CLI-style overrides
+        // and then apply the strongly-typed overrides on top. We still resolve CODEX_HOME to
+        // pass through for paths/auth handling, but we avoid parsing a config file.
         let codex_home = find_codex_home()?;
-        let cfg = load_config_as_toml_with_cli_overrides(&codex_home, cli_overrides)?;
+
+        // Build a base TOML value from dotted CLI overrides only (no file IO).
+        let mut base_tbl: TomlTable = TomlTable::new();
+        for (k, v) in cli_overrides.into_iter() {
+            insert_dotted_toml(&mut base_tbl, &k, v);
+        }
+
+        let root_value = TomlValue::Table(base_tbl);
+        let cfg: ConfigToml = root_value.try_into().map_err(|e| anyhow::anyhow!(e))?;
         Ok(Config::load_from_base_config_with_overrides(cfg, overrides_struct, codex_home)?)
     }
 }
@@ -350,12 +359,46 @@ fn flatten_overrides(out: &mut Vec<(String, TomlValue)>, prefix: &str, val: Toml
     }
 }
 
+/// Insert a TOML value into `tbl` at a dotted path like "a.b.c".
+fn insert_dotted_toml(tbl: &mut TomlTable, dotted: &str, val: TomlValue) {
+    let parts: Vec<&str> = dotted.split('.').collect();
+    insert_parts(tbl, &parts, val);
+}
+
+fn insert_parts(current: &mut TomlTable, parts: &[&str], val: TomlValue) {
+    if parts.is_empty() {
+        return;
+    }
+    if parts.len() == 1 {
+        current.insert(parts[0].to_string(), val);
+        return;
+    }
+
+    let key = parts[0].to_string();
+    // Get or create an intermediate table at this segment.
+    if let Some(existing) = current.get_mut(&key) {
+        match existing {
+            TomlValue::Table(ref mut t) => {
+                insert_parts(t, &parts[1..], val);
+            }
+            _ => {
+                let mut next = TomlTable::new();
+                insert_parts(&mut next, &parts[1..], val);
+                *existing = TomlValue::Table(next);
+            }
+        }
+    } else {
+        let mut next = TomlTable::new();
+        insert_parts(&mut next, &parts[1..], val);
+        current.insert(key, TomlValue::Table(next));
+    }
+}
+
 fn run_exec_stream_impl(prompt: String, config: Config, tx: mpsc::Sender<JsonValue>) -> Result<()> {
     let rt = tokio::runtime::Runtime::new()?;
     rt.block_on(async move {
         let conversation_manager = ConversationManager::new(AuthManager::shared(
             config.codex_home.clone(),
-            config.preferred_auth_method,
         ));
         let new_conv = conversation_manager.new_conversation(config).await?;
         let conversation = new_conv.conversation.clone();