Code mode on v8 (#15276)

Moves Code Mode to a new crate with no dependencies on codex. This
create encodes the code mode semantics that we want for lifetime,
mounting, tool calling.

The model-facing surface is mostly unchanged. `exec` still runs raw
JavaScript, `wait` still resumes or terminates a `cell_id`, nested tools
are still available through `tools.*`, and helpers like `text`, `image`,
`store`, `load`, `notify`, `yield_control`, and `exit` still exist.

The major change is underneath that surface:

- Old code mode was an external Node runtime.
- New code mode is an in-process V8 runtime embedded directly in Rust.
- Old code mode managed cells inside a long-lived Node runner process.
- New code mode manages cells in Rust, with one V8 runtime thread per
active `exec`.
- Old code mode used JSON protocol messages over child stdin/stdout plus
Node worker-thread messages.
- New code mode uses Rust channels and direct V8 callbacks/events.

This PR also fixes the two migration regressions that fell out of that
substrate change:

- `wait { terminate: true }` now waits for the V8 runtime to actually
stop before reporting termination.
- synchronous top-level `exit()` now succeeds again instead of surfacing
as a script error.

---

- `core/src/tools/code_mode/*` is now mostly an adapter layer for the
public `exec` / `wait` tools.
- `code-mode/src/service.rs` owns cell sessions and async control flow
in Rust.
- `code-mode/src/runtime/*.rs` owns the embedded V8 isolate and
JavaScript execution.
- each `exec` spawns a dedicated runtime thread plus a Rust
session-control task.
- helper globals are installed directly into the V8 context instead of
being injected through a source prelude.
- helper modules like `tools.js` and `@openai/code_mode` are synthesized
through V8 module resolution callbacks in Rust.

---

Also added a benchmark for showing the speed of init and use of a code
mode env:
```
$ cargo bench -p codex-code-mode --bench exec_overhead -- --samples 30 --warm-iterations 25 --tool-counts 0,32,128
Finished [`bench` profile [optimized]](https://doc.rust-lang.org/cargo/reference/profiles.html#default-profiles) target(s) in 0.18s
     Running benches/exec_overhead.rs (target/release/deps/exec_overhead-008c440d800545ae)
exec_overhead: samples=30, warm_iterations=25, tool_counts=[0, 32, 128]
scenario       tools samples    warmups      iters      mean/exec       p95/exec       rssΔ p50       rssΔ max
cold_exec          0      30          0          1         1.13ms         1.20ms        8.05MiB        8.06MiB
warm_exec          0      30          1         25       473.43us       512.49us      912.00KiB        1.33MiB
cold_exec         32      30          0          1         1.03ms         1.15ms        8.08MiB        8.11MiB
warm_exec         32      30          1         25       509.73us       545.76us      960.00KiB        1.30MiB
cold_exec        128      30          0          1         1.14ms         1.19ms        8.30MiB        8.34MiB
warm_exec        128      30          1         25       575.08us       591.03us      736.00KiB      864.00KiB
memory uses a fresh-process max RSS delta for each scenario
```

---------

Co-authored-by: Codex <noreply@openai.com>

codex-rs/code-mode/src/runtime/callbacks.rs

@@ -0,0 +1,209 @@
+use crate::response::FunctionCallOutputContentItem;
+
+use super::EXIT_SENTINEL;
+use super::RuntimeEvent;
+use super::RuntimeState;
+use super::value::json_to_v8;
+use super::value::normalize_output_image;
+use super::value::serialize_output_text;
+use super::value::throw_type_error;
+use super::value::v8_value_to_json;
+
+pub(super) fn tool_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue<v8::Value>,
+) {
+    let tool_name = args.data().to_rust_string_lossy(scope);
+    let input = if args.length() == 0 {
+        Ok(None)
+    } else {
+        v8_value_to_json(scope, args.get(0))
+    };
+    let input = match input {
+        Ok(input) => input,
+        Err(error_text) => {
+            throw_type_error(scope, &error_text);
+            return;
+        }
+    };
+
+    let Some(resolver) = v8::PromiseResolver::new(scope) else {
+        throw_type_error(scope, "failed to create tool promise");
+        return;
+    };
+    let promise = resolver.get_promise(scope);
+
+    let resolver = v8::Global::new(scope, resolver);
+    let Some(state) = scope.get_slot_mut::<RuntimeState>() else {
+        throw_type_error(scope, "runtime state unavailable");
+        return;
+    };
+    let id = format!("tool-{}", state.next_tool_call_id);
+    state.next_tool_call_id = state.next_tool_call_id.saturating_add(1);
+    let event_tx = state.event_tx.clone();
+    state.pending_tool_calls.insert(id.clone(), resolver);
+    let _ = event_tx.send(RuntimeEvent::ToolCall {
+        id,
+        name: tool_name,
+        input,
+    });
+    retval.set(promise.into());
+}
+
+pub(super) fn text_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue<v8::Value>,
+) {
+    let value = if args.length() == 0 {
+        v8::undefined(scope).into()
+    } else {
+        args.get(0)
+    };
+    let text = match serialize_output_text(scope, value) {
+        Ok(text) => text,
+        Err(error_text) => {
+            throw_type_error(scope, &error_text);
+            return;
+        }
+    };
+    if let Some(state) = scope.get_slot::<RuntimeState>() {
+        let _ = state.event_tx.send(RuntimeEvent::ContentItem(
+            FunctionCallOutputContentItem::InputText { text },
+        ));
+    }
+    retval.set(v8::undefined(scope).into());
+}
+
+pub(super) fn image_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue<v8::Value>,
+) {
+    let value = if args.length() == 0 {
+        v8::undefined(scope).into()
+    } else {
+        args.get(0)
+    };
+    let image_item = match normalize_output_image(scope, value) {
+        Ok(image_item) => image_item,
+        Err(()) => return,
+    };
+    if let Some(state) = scope.get_slot::<RuntimeState>() {
+        let _ = state.event_tx.send(RuntimeEvent::ContentItem(image_item));
+    }
+    retval.set(v8::undefined(scope).into());
+}
+
+pub(super) fn store_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    _retval: v8::ReturnValue<v8::Value>,
+) {
+    let key = match args.get(0).to_string(scope) {
+        Some(key) => key.to_rust_string_lossy(scope),
+        None => {
+            throw_type_error(scope, "store key must be a string");
+            return;
+        }
+    };
+    let value = args.get(1);
+    let serialized = match v8_value_to_json(scope, value) {
+        Ok(Some(value)) => value,
+        Ok(None) => {
+            throw_type_error(
+                scope,
+                &format!("Unable to store {key:?}. Only plain serializable objects can be stored."),
+            );
+            return;
+        }
+        Err(error_text) => {
+            throw_type_error(scope, &error_text);
+            return;
+        }
+    };
+    if let Some(state) = scope.get_slot_mut::<RuntimeState>() {
+        state.stored_values.insert(key, serialized);
+    }
+}
+
+pub(super) fn load_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue<v8::Value>,
+) {
+    let key = match args.get(0).to_string(scope) {
+        Some(key) => key.to_rust_string_lossy(scope),
+        None => {
+            throw_type_error(scope, "load key must be a string");
+            return;
+        }
+    };
+    let value = scope
+        .get_slot::<RuntimeState>()
+        .and_then(|state| state.stored_values.get(&key))
+        .cloned();
+    let Some(value) = value else {
+        retval.set(v8::undefined(scope).into());
+        return;
+    };
+    let Some(value) = json_to_v8(scope, &value) else {
+        throw_type_error(scope, "failed to load stored value");
+        return;
+    };
+    retval.set(value);
+}
+
+pub(super) fn notify_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    args: v8::FunctionCallbackArguments,
+    mut retval: v8::ReturnValue<v8::Value>,
+) {
+    let value = if args.length() == 0 {
+        v8::undefined(scope).into()
+    } else {
+        args.get(0)
+    };
+    let text = match serialize_output_text(scope, value) {
+        Ok(text) => text,
+        Err(error_text) => {
+            throw_type_error(scope, &error_text);
+            return;
+        }
+    };
+    if text.trim().is_empty() {
+        throw_type_error(scope, "notify expects non-empty text");
+        return;
+    }
+    if let Some(state) = scope.get_slot::<RuntimeState>() {
+        let _ = state.event_tx.send(RuntimeEvent::Notify {
+            call_id: state.tool_call_id.clone(),
+            text,
+        });
+    }
+    retval.set(v8::undefined(scope).into());
+}
+
+pub(super) fn yield_control_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    _args: v8::FunctionCallbackArguments,
+    _retval: v8::ReturnValue<v8::Value>,
+) {
+    if let Some(state) = scope.get_slot::<RuntimeState>() {
+        let _ = state.event_tx.send(RuntimeEvent::YieldRequested);
+    }
+}
+
+pub(super) fn exit_callback(
+    scope: &mut v8::PinScope<'_, '_>,
+    _args: v8::FunctionCallbackArguments,
+    _retval: v8::ReturnValue<v8::Value>,
+) {
+    if let Some(state) = scope.get_slot_mut::<RuntimeState>() {
+        state.exit_requested = true;
+    }
+    if let Some(error) = v8::String::new(scope, EXIT_SENTINEL) {
+        scope.throw_exception(error.into());
+    }
+}

codex-rs/code-mode/src/runtime/globals.rs

@@ -0,0 +1,138 @@
+use super::RuntimeState;
+use super::callbacks::exit_callback;
+use super::callbacks::image_callback;
+use super::callbacks::load_callback;
+use super::callbacks::notify_callback;
+use super::callbacks::store_callback;
+use super::callbacks::text_callback;
+use super::callbacks::tool_callback;
+use super::callbacks::yield_control_callback;
+
+pub(super) fn install_globals(scope: &mut v8::PinScope<'_, '_>) -> Result<(), String> {
+    let global = scope.get_current_context().global(scope);
+    let console = v8::String::new(scope, "console")
+        .ok_or_else(|| "failed to allocate global `console`".to_string())?;
+    if global.delete(scope, console.into()) != Some(true) {
+        return Err("failed to remove global `console`".to_string());
+    }
+
+    let tools = build_tools_object(scope)?;
+    let all_tools = build_all_tools_value(scope)?;
+    let text = helper_function(scope, "text", text_callback)?;
+    let image = helper_function(scope, "image", image_callback)?;
+    let store = helper_function(scope, "store", store_callback)?;
+    let load = helper_function(scope, "load", load_callback)?;
+    let notify = helper_function(scope, "notify", notify_callback)?;
+    let yield_control = helper_function(scope, "yield_control", yield_control_callback)?;
+    let exit = helper_function(scope, "exit", exit_callback)?;
+
+    set_global(scope, global, "tools", tools.into())?;
+    set_global(scope, global, "ALL_TOOLS", all_tools)?;
+    set_global(scope, global, "text", text.into())?;
+    set_global(scope, global, "image", image.into())?;
+    set_global(scope, global, "store", store.into())?;
+    set_global(scope, global, "load", load.into())?;
+    set_global(scope, global, "notify", notify.into())?;
+    set_global(scope, global, "yield_control", yield_control.into())?;
+    set_global(scope, global, "exit", exit.into())?;
+    Ok(())
+}
+
+fn build_tools_object<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+) -> Result<v8::Local<'s, v8::Object>, String> {
+    let tools = v8::Object::new(scope);
+    let enabled_tools = scope
+        .get_slot::<RuntimeState>()
+        .map(|state| state.enabled_tools.clone())
+        .unwrap_or_default();
+
+    for tool in enabled_tools {
+        let name = v8::String::new(scope, &tool.global_name)
+            .ok_or_else(|| "failed to allocate tool name".to_string())?;
+        let function = tool_function(scope, &tool.tool_name)?;
+        tools.set(scope, name.into(), function.into());
+    }
+    Ok(tools)
+}
+
+fn build_all_tools_value<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+) -> Result<v8::Local<'s, v8::Value>, String> {
+    let enabled_tools = scope
+        .get_slot::<RuntimeState>()
+        .map(|state| state.enabled_tools.clone())
+        .unwrap_or_default();
+    let array = v8::Array::new(scope, enabled_tools.len() as i32);
+    let name_key = v8::String::new(scope, "name")
+        .ok_or_else(|| "failed to allocate ALL_TOOLS name key".to_string())?;
+    let description_key = v8::String::new(scope, "description")
+        .ok_or_else(|| "failed to allocate ALL_TOOLS description key".to_string())?;
+
+    for (index, tool) in enabled_tools.iter().enumerate() {
+        let item = v8::Object::new(scope);
+        let name = v8::String::new(scope, &tool.global_name)
+            .ok_or_else(|| "failed to allocate ALL_TOOLS name".to_string())?;
+        let description = v8::String::new(scope, &tool.description)
+            .ok_or_else(|| "failed to allocate ALL_TOOLS description".to_string())?;
+
+        if item.set(scope, name_key.into(), name.into()) != Some(true) {
+            return Err("failed to set ALL_TOOLS name".to_string());
+        }
+        if item.set(scope, description_key.into(), description.into()) != Some(true) {
+            return Err("failed to set ALL_TOOLS description".to_string());
+        }
+        if array.set_index(scope, index as u32, item.into()) != Some(true) {
+            return Err("failed to append ALL_TOOLS metadata".to_string());
+        }
+    }
+
+    Ok(array.into())
+}
+
+fn helper_function<'s, F>(
+    scope: &mut v8::PinScope<'s, '_>,
+    name: &str,
+    callback: F,
+) -> Result<v8::Local<'s, v8::Function>, String>
+where
+    F: v8::MapFnTo<v8::FunctionCallback>,
+{
+    let name =
+        v8::String::new(scope, name).ok_or_else(|| "failed to allocate helper name".to_string())?;
+    let template = v8::FunctionTemplate::builder(callback)
+        .data(name.into())
+        .build(scope);
+    template
+        .get_function(scope)
+        .ok_or_else(|| "failed to create helper function".to_string())
+}
+
+fn tool_function<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    tool_name: &str,
+) -> Result<v8::Local<'s, v8::Function>, String> {
+    let data = v8::String::new(scope, tool_name)
+        .ok_or_else(|| "failed to allocate tool callback data".to_string())?;
+    let template = v8::FunctionTemplate::builder(tool_callback)
+        .data(data.into())
+        .build(scope);
+    template
+        .get_function(scope)
+        .ok_or_else(|| "failed to create tool function".to_string())
+}
+
+fn set_global<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    global: v8::Local<'s, v8::Object>,
+    name: &str,
+    value: v8::Local<'s, v8::Value>,
+) -> Result<(), String> {
+    let key = v8::String::new(scope, name)
+        .ok_or_else(|| format!("failed to allocate global `{name}`"))?;
+    if global.set(scope, key.into(), value) == Some(true) {
+        Ok(())
+    } else {
+        Err(format!("failed to set global `{name}`"))
+    }
+}

codex-rs/code-mode/src/runtime/mod.rs

@@ -0,0 +1,349 @@
+mod callbacks;
+mod globals;
+mod module_loader;
+mod value;
+
+use std::collections::HashMap;
+use std::sync::OnceLock;
+use std::sync::mpsc as std_mpsc;
+use std::thread;
+
+use serde_json::Value as JsonValue;
+use tokio::sync::mpsc;
+
+use crate::description::EnabledToolMetadata;
+use crate::description::ToolDefinition;
+use crate::description::enabled_tool_metadata;
+use crate::response::FunctionCallOutputContentItem;
+
+pub const DEFAULT_EXEC_YIELD_TIME_MS: u64 = 10_000;
+pub const DEFAULT_WAIT_YIELD_TIME_MS: u64 = 10_000;
+pub const DEFAULT_MAX_OUTPUT_TOKENS_PER_EXEC_CALL: usize = 10_000;
+const EXIT_SENTINEL: &str = "__codex_code_mode_exit__";
+
+#[derive(Clone, Debug)]
+pub struct ExecuteRequest {
+    pub tool_call_id: String,
+    pub enabled_tools: Vec<ToolDefinition>,
+    pub source: String,
+    pub stored_values: HashMap<String, JsonValue>,
+    pub yield_time_ms: Option<u64>,
+    pub max_output_tokens: Option<usize>,
+}
+
+#[derive(Clone, Debug)]
+pub struct WaitRequest {
+    pub cell_id: String,
+    pub yield_time_ms: u64,
+    pub terminate: bool,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum RuntimeResponse {
+    Yielded {
+        cell_id: String,
+        content_items: Vec<FunctionCallOutputContentItem>,
+    },
+    Terminated {
+        cell_id: String,
+        content_items: Vec<FunctionCallOutputContentItem>,
+    },
+    Result {
+        cell_id: String,
+        content_items: Vec<FunctionCallOutputContentItem>,
+        stored_values: HashMap<String, JsonValue>,
+        error_text: Option<String>,
+    },
+}
+
+#[derive(Debug)]
+pub(crate) enum TurnMessage {
+    ToolCall {
+        cell_id: String,
+        id: String,
+        name: String,
+        input: Option<JsonValue>,
+    },
+    Notify {
+        cell_id: String,
+        call_id: String,
+        text: String,
+    },
+}
+
+#[derive(Debug)]
+pub(crate) enum RuntimeCommand {
+    ToolResponse { id: String, result: JsonValue },
+    ToolError { id: String, error_text: String },
+    Terminate,
+}
+
+#[derive(Debug)]
+pub(crate) enum RuntimeEvent {
+    Started,
+    ContentItem(FunctionCallOutputContentItem),
+    YieldRequested,
+    ToolCall {
+        id: String,
+        name: String,
+        input: Option<JsonValue>,
+    },
+    Notify {
+        call_id: String,
+        text: String,
+    },
+    Result {
+        stored_values: HashMap<String, JsonValue>,
+        error_text: Option<String>,
+    },
+}
+
+pub(crate) fn spawn_runtime(
+    request: ExecuteRequest,
+    event_tx: mpsc::UnboundedSender<RuntimeEvent>,
+) -> Result<(std_mpsc::Sender<RuntimeCommand>, v8::IsolateHandle), String> {
+    let (command_tx, command_rx) = std_mpsc::channel();
+    let (isolate_handle_tx, isolate_handle_rx) = std_mpsc::sync_channel(1);
+    let enabled_tools = request
+        .enabled_tools
+        .iter()
+        .map(enabled_tool_metadata)
+        .collect::<Vec<_>>();
+    let config = RuntimeConfig {
+        tool_call_id: request.tool_call_id,
+        enabled_tools,
+        source: request.source,
+        stored_values: request.stored_values,
+    };
+
+    thread::spawn(move || {
+        run_runtime(config, event_tx, command_rx, isolate_handle_tx);
+    });
+
+    let isolate_handle = isolate_handle_rx
+        .recv()
+        .map_err(|_| "failed to initialize code mode runtime".to_string())?;
+    Ok((command_tx, isolate_handle))
+}
+
+#[derive(Clone)]
+struct RuntimeConfig {
+    tool_call_id: String,
+    enabled_tools: Vec<EnabledToolMetadata>,
+    source: String,
+    stored_values: HashMap<String, JsonValue>,
+}
+
+pub(super) struct RuntimeState {
+    event_tx: mpsc::UnboundedSender<RuntimeEvent>,
+    pending_tool_calls: HashMap<String, v8::Global<v8::PromiseResolver>>,
+    stored_values: HashMap<String, JsonValue>,
+    enabled_tools: Vec<EnabledToolMetadata>,
+    next_tool_call_id: u64,
+    tool_call_id: String,
+    exit_requested: bool,
+}
+
+pub(super) enum CompletionState {
+    Pending,
+    Completed {
+        stored_values: HashMap<String, JsonValue>,
+        error_text: Option<String>,
+    },
+}
+
+fn initialize_v8() {
+    static PLATFORM: OnceLock<v8::SharedRef<v8::Platform>> = OnceLock::new();
+
+    let _ = PLATFORM.get_or_init(|| {
+        let platform = v8::new_default_platform(0, false).make_shared();
+        v8::V8::initialize_platform(platform.clone());
+        v8::V8::initialize();
+        platform
+    });
+}
+
+fn run_runtime(
+    config: RuntimeConfig,
+    event_tx: mpsc::UnboundedSender<RuntimeEvent>,
+    command_rx: std_mpsc::Receiver<RuntimeCommand>,
+    isolate_handle_tx: std_mpsc::SyncSender<v8::IsolateHandle>,
+) {
+    initialize_v8();
+
+    let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
+    let isolate_handle = isolate.thread_safe_handle();
+    if isolate_handle_tx.send(isolate_handle).is_err() {
+        return;
+    }
+    isolate.set_host_import_module_dynamically_callback(module_loader::dynamic_import_callback);
+
+    v8::scope!(let scope, isolate);
+    let context = v8::Context::new(scope, Default::default());
+    let scope = &mut v8::ContextScope::new(scope, context);
+
+    scope.set_slot(RuntimeState {
+        event_tx: event_tx.clone(),
+        pending_tool_calls: HashMap::new(),
+        stored_values: config.stored_values,
+        enabled_tools: config.enabled_tools,
+        next_tool_call_id: 1,
+        tool_call_id: config.tool_call_id,
+        exit_requested: false,
+    });
+
+    if let Err(error_text) = globals::install_globals(scope) {
+        send_result(&event_tx, HashMap::new(), Some(error_text));
+        return;
+    }
+
+    let _ = event_tx.send(RuntimeEvent::Started);
+
+    let pending_promise = match module_loader::evaluate_main_module(scope, &config.source) {
+        Ok(pending_promise) => pending_promise,
+        Err(error_text) => {
+            capture_scope_send_error(scope, &event_tx, Some(error_text));
+            return;
+        }
+    };
+
+    match module_loader::completion_state(scope, pending_promise.as_ref()) {
+        CompletionState::Completed {
+            stored_values,
+            error_text,
+        } => {
+            send_result(&event_tx, stored_values, error_text);
+            return;
+        }
+        CompletionState::Pending => {}
+    }
+
+    let mut pending_promise = pending_promise;
+    loop {
+        let Ok(command) = command_rx.recv() else {
+            break;
+        };
+        match command {
+            RuntimeCommand::Terminate => break,
+            RuntimeCommand::ToolResponse { id, result } => {
+                if let Err(error_text) =
+                    module_loader::resolve_tool_response(scope, &id, Ok(result))
+                {
+                    capture_scope_send_error(scope, &event_tx, Some(error_text));
+                    return;
+                }
+            }
+            RuntimeCommand::ToolError { id, error_text } => {
+                if let Err(runtime_error) =
+                    module_loader::resolve_tool_response(scope, &id, Err(error_text))
+                {
+                    capture_scope_send_error(scope, &event_tx, Some(runtime_error));
+                    return;
+                }
+            }
+        }
+
+        scope.perform_microtask_checkpoint();
+        match module_loader::completion_state(scope, pending_promise.as_ref()) {
+            CompletionState::Completed {
+                stored_values,
+                error_text,
+            } => {
+                send_result(&event_tx, stored_values, error_text);
+                return;
+            }
+            CompletionState::Pending => {}
+        }
+
+        if let Some(promise) = pending_promise.as_ref() {
+            let promise = v8::Local::new(scope, promise);
+            if promise.state() != v8::PromiseState::Pending {
+                pending_promise = None;
+            }
+        }
+    }
+}
+
+fn capture_scope_send_error(
+    scope: &mut v8::PinScope<'_, '_>,
+    event_tx: &mpsc::UnboundedSender<RuntimeEvent>,
+    error_text: Option<String>,
+) {
+    let stored_values = scope
+        .get_slot::<RuntimeState>()
+        .map(|state| state.stored_values.clone())
+        .unwrap_or_default();
+
+    send_result(event_tx, stored_values, error_text);
+}
+
+fn send_result(
+    event_tx: &mpsc::UnboundedSender<RuntimeEvent>,
+    stored_values: HashMap<String, JsonValue>,
+    error_text: Option<String>,
+) {
+    let _ = event_tx.send(RuntimeEvent::Result {
+        stored_values,
+        error_text,
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::time::Duration;
+
+    use pretty_assertions::assert_eq;
+    use tokio::sync::mpsc;
+
+    use super::ExecuteRequest;
+    use super::RuntimeEvent;
+    use super::spawn_runtime;
+
+    fn execute_request(source: &str) -> ExecuteRequest {
+        ExecuteRequest {
+            tool_call_id: "call_1".to_string(),
+            enabled_tools: Vec::new(),
+            source: source.to_string(),
+            stored_values: HashMap::new(),
+            yield_time_ms: Some(1),
+            max_output_tokens: None,
+        }
+    }
+
+    #[tokio::test]
+    async fn terminate_execution_stops_cpu_bound_module() {
+        let (event_tx, mut event_rx) = mpsc::unbounded_channel();
+        let (_runtime_tx, runtime_terminate_handle) =
+            spawn_runtime(execute_request("while (true) {}"), event_tx).unwrap();
+
+        let started_event = tokio::time::timeout(Duration::from_secs(1), event_rx.recv())
+            .await
+            .unwrap()
+            .unwrap();
+        assert!(matches!(started_event, RuntimeEvent::Started));
+
+        assert!(runtime_terminate_handle.terminate_execution());
+
+        let result_event = tokio::time::timeout(Duration::from_secs(1), event_rx.recv())
+            .await
+            .unwrap()
+            .unwrap();
+        let RuntimeEvent::Result {
+            stored_values,
+            error_text,
+        } = result_event
+        else {
+            panic!("expected runtime result after termination");
+        };
+        assert_eq!(stored_values, HashMap::new());
+        assert!(error_text.is_some());
+
+        assert!(
+            tokio::time::timeout(Duration::from_secs(1), event_rx.recv())
+                .await
+                .unwrap()
+                .is_none()
+        );
+    }
+}

codex-rs/code-mode/src/runtime/module_loader.rs

@@ -0,0 +1,235 @@
+use serde_json::Value as JsonValue;
+
+use super::CompletionState;
+use super::EXIT_SENTINEL;
+use super::RuntimeState;
+use super::value::json_to_v8;
+use super::value::value_to_error_text;
+
+pub(super) fn evaluate_main_module(
+    scope: &mut v8::PinScope<'_, '_>,
+    source_text: &str,
+) -> Result<Option<v8::Global<v8::Promise>>, String> {
+    let tc = std::pin::pin!(v8::TryCatch::new(scope));
+    let mut tc = tc.init();
+    let source = v8::String::new(&tc, source_text)
+        .ok_or_else(|| "failed to allocate exec source".to_string())?;
+    let origin = script_origin(&mut tc, "exec_main.mjs")?;
+    let mut source = v8::script_compiler::Source::new(source, Some(&origin));
+    let module = v8::script_compiler::compile_module(&tc, &mut source).ok_or_else(|| {
+        tc.exception()
+            .map(|exception| value_to_error_text(&mut tc, exception))
+            .unwrap_or_else(|| "unknown code mode exception".to_string())
+    })?;
+    module
+        .instantiate_module(&tc, resolve_module_callback)
+        .ok_or_else(|| {
+            tc.exception()
+                .map(|exception| value_to_error_text(&mut tc, exception))
+                .unwrap_or_else(|| "unknown code mode exception".to_string())
+        })?;
+    let result = match module.evaluate(&tc) {
+        Some(result) => result,
+        None => {
+            if let Some(exception) = tc.exception() {
+                if is_exit_exception(&mut tc, exception) {
+                    return Ok(None);
+                }
+                return Err(value_to_error_text(&mut tc, exception));
+            }
+            return Err("unknown code mode exception".to_string());
+        }
+    };
+    tc.perform_microtask_checkpoint();
+
+    if result.is_promise() {
+        let promise = v8::Local::<v8::Promise>::try_from(result)
+            .map_err(|_| "failed to read exec promise".to_string())?;
+        return Ok(Some(v8::Global::new(&tc, promise)));
+    }
+
+    Ok(None)
+}
+
+fn is_exit_exception(
+    scope: &mut v8::PinScope<'_, '_>,
+    exception: v8::Local<'_, v8::Value>,
+) -> bool {
+    scope
+        .get_slot::<RuntimeState>()
+        .map(|state| state.exit_requested)
+        .unwrap_or(false)
+        && exception.is_string()
+        && exception.to_rust_string_lossy(scope) == EXIT_SENTINEL
+}
+
+pub(super) fn resolve_tool_response(
+    scope: &mut v8::PinScope<'_, '_>,
+    id: &str,
+    response: Result<JsonValue, String>,
+) -> Result<(), String> {
+    let resolver = {
+        let state = scope
+            .get_slot_mut::<RuntimeState>()
+            .ok_or_else(|| "runtime state unavailable".to_string())?;
+        state.pending_tool_calls.remove(id)
+    }
+    .ok_or_else(|| format!("unknown tool call `{id}`"))?;
+
+    let tc = std::pin::pin!(v8::TryCatch::new(scope));
+    let mut tc = tc.init();
+    let resolver = v8::Local::new(&tc, &resolver);
+    match response {
+        Ok(result) => {
+            let value = json_to_v8(&mut tc, &result)
+                .ok_or_else(|| "failed to serialize tool response".to_string())?;
+            resolver.resolve(&tc, value);
+        }
+        Err(error_text) => {
+            let value = v8::String::new(&tc, &error_text)
+                .ok_or_else(|| "failed to allocate tool error".to_string())?;
+            resolver.reject(&tc, value.into());
+        }
+    }
+    if tc.has_caught() {
+        return Err(tc
+            .exception()
+            .map(|exception| value_to_error_text(&mut tc, exception))
+            .unwrap_or_else(|| "unknown code mode exception".to_string()));
+    }
+    Ok(())
+}
+
+pub(super) fn completion_state(
+    scope: &mut v8::PinScope<'_, '_>,
+    pending_promise: Option<&v8::Global<v8::Promise>>,
+) -> CompletionState {
+    let stored_values = scope
+        .get_slot::<RuntimeState>()
+        .map(|state| state.stored_values.clone())
+        .unwrap_or_default();
+
+    let Some(pending_promise) = pending_promise else {
+        return CompletionState::Completed {
+            stored_values,
+            error_text: None,
+        };
+    };
+
+    let promise = v8::Local::new(scope, pending_promise);
+    match promise.state() {
+        v8::PromiseState::Pending => CompletionState::Pending,
+        v8::PromiseState::Fulfilled => CompletionState::Completed {
+            stored_values,
+            error_text: None,
+        },
+        v8::PromiseState::Rejected => {
+            let result = promise.result(scope);
+            let error_text = if is_exit_exception(scope, result) {
+                None
+            } else {
+                Some(value_to_error_text(scope, result))
+            };
+            CompletionState::Completed {
+                stored_values,
+                error_text,
+            }
+        }
+    }
+}
+
+fn script_origin<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    resource_name_: &str,
+) -> Result<v8::ScriptOrigin<'s>, String> {
+    let resource_name = v8::String::new(scope, resource_name_)
+        .ok_or_else(|| "failed to allocate script origin".to_string())?;
+    let source_map_url = v8::String::new(scope, resource_name_)
+        .ok_or_else(|| "failed to allocate source map url".to_string())?;
+    Ok(v8::ScriptOrigin::new(
+        scope,
+        resource_name.into(),
+        0,
+        0,
+        true,
+        0,
+        Some(source_map_url.into()),
+        true,
+        false,
+        true,
+        None,
+    ))
+}
+
+fn resolve_module_callback<'s>(
+    context: v8::Local<'s, v8::Context>,
+    specifier: v8::Local<'s, v8::String>,
+    _import_attributes: v8::Local<'s, v8::FixedArray>,
+    _referrer: v8::Local<'s, v8::Module>,
+) -> Option<v8::Local<'s, v8::Module>> {
+    v8::callback_scope!(unsafe scope, context);
+    let specifier = specifier.to_rust_string_lossy(scope);
+    resolve_module(scope, &specifier)
+}
+
+pub(super) fn dynamic_import_callback<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    _host_defined_options: v8::Local<'s, v8::Data>,
+    _resource_name: v8::Local<'s, v8::Value>,
+    specifier: v8::Local<'s, v8::String>,
+    _import_attributes: v8::Local<'s, v8::FixedArray>,
+) -> Option<v8::Local<'s, v8::Promise>> {
+    let specifier = specifier.to_rust_string_lossy(scope);
+    let resolver = v8::PromiseResolver::new(scope)?;
+
+    match resolve_module(scope, &specifier) {
+        Some(module) => {
+            if module.get_status() == v8::ModuleStatus::Uninstantiated
+                && module
+                    .instantiate_module(scope, resolve_module_callback)
+                    .is_none()
+            {
+                let error = v8::String::new(scope, "failed to instantiate module")
+                    .map(Into::into)
+                    .unwrap_or_else(|| v8::undefined(scope).into());
+                resolver.reject(scope, error);
+                return Some(resolver.get_promise(scope));
+            }
+            if matches!(
+                module.get_status(),
+                v8::ModuleStatus::Instantiated | v8::ModuleStatus::Evaluated
+            ) && module.evaluate(scope).is_none()
+            {
+                let error = v8::String::new(scope, "failed to evaluate module")
+                    .map(Into::into)
+                    .unwrap_or_else(|| v8::undefined(scope).into());
+                resolver.reject(scope, error);
+                return Some(resolver.get_promise(scope));
+            }
+            let namespace = module.get_module_namespace();
+            resolver.resolve(scope, namespace);
+            Some(resolver.get_promise(scope))
+        }
+        None => {
+            let error = v8::String::new(scope, "unsupported import in exec")
+                .map(Into::into)
+                .unwrap_or_else(|| v8::undefined(scope).into());
+            resolver.reject(scope, error);
+            Some(resolver.get_promise(scope))
+        }
+    }
+}
+
+fn resolve_module<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    specifier: &str,
+) -> Option<v8::Local<'s, v8::Module>> {
+    if let Some(message) =
+        v8::String::new(scope, &format!("Unsupported import in exec: {specifier}"))
+    {
+        scope.throw_exception(message.into());
+    } else {
+        scope.throw_exception(v8::undefined(scope).into());
+    }
+    None
+}

codex-rs/code-mode/src/runtime/value.rs

@@ -0,0 +1,163 @@
+use serde_json::Value as JsonValue;
+
+use crate::response::FunctionCallOutputContentItem;
+use crate::response::ImageDetail;
+
+pub(super) fn serialize_output_text(
+    scope: &mut v8::PinScope<'_, '_>,
+    value: v8::Local<'_, v8::Value>,
+) -> Result<String, String> {
+    if value.is_undefined()
+        || value.is_null()
+        || value.is_boolean()
+        || value.is_number()
+        || value.is_big_int()
+        || value.is_string()
+    {
+        return Ok(value.to_rust_string_lossy(scope));
+    }
+
+    let tc = std::pin::pin!(v8::TryCatch::new(scope));
+    let mut tc = tc.init();
+    if let Some(stringified) = v8::json::stringify(&tc, value) {
+        return Ok(stringified.to_rust_string_lossy(&tc));
+    }
+    if tc.has_caught() {
+        return Err(tc
+            .exception()
+            .map(|exception| value_to_error_text(&mut tc, exception))
+            .unwrap_or_else(|| "unknown code mode exception".to_string()));
+    }
+    Ok(value.to_rust_string_lossy(&tc))
+}
+
+pub(super) fn normalize_output_image(
+    scope: &mut v8::PinScope<'_, '_>,
+    value: v8::Local<'_, v8::Value>,
+) -> Result<FunctionCallOutputContentItem, ()> {
+    let result = (|| -> Result<FunctionCallOutputContentItem, String> {
+        let (image_url, detail) = if value.is_string() {
+            (value.to_rust_string_lossy(scope), None)
+        } else if value.is_object() && !value.is_array() {
+            let object = v8::Local::<v8::Object>::try_from(value).map_err(|_| {
+                "image expects a non-empty image URL string or an object with image_url and optional detail".to_string()
+            })?;
+            let image_url_key = v8::String::new(scope, "image_url")
+                .ok_or_else(|| "failed to allocate image helper keys".to_string())?;
+            let detail_key = v8::String::new(scope, "detail")
+                .ok_or_else(|| "failed to allocate image helper keys".to_string())?;
+            let image_url = object
+                .get(scope, image_url_key.into())
+                .filter(|value| value.is_string())
+                .map(|value| value.to_rust_string_lossy(scope))
+                .ok_or_else(|| {
+                    "image expects a non-empty image URL string or an object with image_url and optional detail"
+                        .to_string()
+                })?;
+            let detail = match object.get(scope, detail_key.into()) {
+                Some(value) if value.is_string() => Some(value.to_rust_string_lossy(scope)),
+                Some(value) if value.is_null() || value.is_undefined() => None,
+                Some(_) => return Err("image detail must be a string when provided".to_string()),
+                None => None,
+            };
+            (image_url, detail)
+        } else {
+            return Err(
+                "image expects a non-empty image URL string or an object with image_url and optional detail"
+                    .to_string(),
+            );
+        };
+
+        if image_url.is_empty() {
+            return Err(
+                "image expects a non-empty image URL string or an object with image_url and optional detail"
+                    .to_string(),
+            );
+        }
+        let lower = image_url.to_ascii_lowercase();
+        if !(lower.starts_with("http://")
+            || lower.starts_with("https://")
+            || lower.starts_with("data:"))
+        {
+            return Err("image expects an http(s) or data URL".to_string());
+        }
+
+        let detail = match detail {
+            Some(detail) => {
+                let normalized = detail.to_ascii_lowercase();
+                Some(match normalized.as_str() {
+                    "auto" => ImageDetail::Auto,
+                    "low" => ImageDetail::Low,
+                    "high" => ImageDetail::High,
+                    "original" => ImageDetail::Original,
+                    _ => {
+                        return Err(
+                            "image detail must be one of: auto, low, high, original".to_string()
+                        );
+                    }
+                })
+            }
+            None => None,
+        };
+
+        Ok(FunctionCallOutputContentItem::InputImage { image_url, detail })
+    })();
+
+    match result {
+        Ok(item) => Ok(item),
+        Err(error_text) => {
+            throw_type_error(scope, &error_text);
+            Err(())
+        }
+    }
+}
+
+pub(super) fn v8_value_to_json(
+    scope: &mut v8::PinScope<'_, '_>,
+    value: v8::Local<'_, v8::Value>,
+) -> Result<Option<JsonValue>, String> {
+    let tc = std::pin::pin!(v8::TryCatch::new(scope));
+    let mut tc = tc.init();
+    let Some(stringified) = v8::json::stringify(&tc, value) else {
+        if tc.has_caught() {
+            return Err(tc
+                .exception()
+                .map(|exception| value_to_error_text(&mut tc, exception))
+                .unwrap_or_else(|| "unknown code mode exception".to_string()));
+        }
+        return Ok(None);
+    };
+    serde_json::from_str(&stringified.to_rust_string_lossy(&tc))
+        .map(Some)
+        .map_err(|err| format!("failed to serialize JavaScript value: {err}"))
+}
+
+pub(super) fn json_to_v8<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    value: &JsonValue,
+) -> Option<v8::Local<'s, v8::Value>> {
+    let json = serde_json::to_string(value).ok()?;
+    let json = v8::String::new(scope, &json)?;
+    v8::json::parse(scope, json)
+}
+
+pub(super) fn value_to_error_text(
+    scope: &mut v8::PinScope<'_, '_>,
+    value: v8::Local<'_, v8::Value>,
+) -> String {
+    if value.is_object()
+        && let Ok(object) = v8::Local::<v8::Object>::try_from(value)
+        && let Some(key) = v8::String::new(scope, "stack")
+        && let Some(stack) = object.get(scope, key.into())
+        && stack.is_string()
+    {
+        return stack.to_rust_string_lossy(scope);
+    }
+    value.to_rust_string_lossy(scope)
+}
+
+pub(super) fn throw_type_error(scope: &mut v8::PinScope<'_, '_>, message: &str) {
+    if let Some(message) = v8::String::new(scope, message) {
+        scope.throw_exception(message.into());
+    }
+}