mirror of
https://github.com/openai/codex.git
synced 2026-11-21 22:50:37 +00:00
code-mode: expose create and observe operations
This commit is contained in:
Generated
-1
@@ -2517,7 +2517,6 @@ dependencies = [
|
||||
"pretty_assertions",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"tokio",
|
||||
"tokio-util",
|
||||
]
|
||||
|
||||
|
||||
@@ -16,9 +16,7 @@ workspace = true
|
||||
codex-protocol = { workspace = true }
|
||||
serde = { workspace = true, features = ["derive"] }
|
||||
serde_json = { workspace = true }
|
||||
tokio = { workspace = true, features = ["io-util", "sync"] }
|
||||
tokio-util = { workspace = true, features = ["rt"] }
|
||||
|
||||
[dev-dependencies]
|
||||
pretty_assertions = { workspace = true }
|
||||
tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
|
||||
|
||||
@@ -20,17 +20,17 @@ pub use description::render_json_schema_to_typescript;
|
||||
pub use response::DEFAULT_IMAGE_DETAIL;
|
||||
pub use response::FunctionCallOutputContentItem;
|
||||
pub use response::ImageDetail;
|
||||
pub use runtime::CellOutcome;
|
||||
pub use runtime::CodeModeNestedToolCall;
|
||||
pub use runtime::CreateCellRequest;
|
||||
pub use runtime::DEFAULT_EXEC_YIELD_TIME_MS;
|
||||
pub use runtime::DEFAULT_MAX_OUTPUT_TOKENS_PER_EXEC_CALL;
|
||||
pub use runtime::DEFAULT_WAIT_YIELD_TIME_MS;
|
||||
pub use runtime::ExecuteRequest;
|
||||
pub use runtime::ExecuteToPendingOutcome;
|
||||
pub use runtime::ObserveRequest;
|
||||
pub use runtime::ObserveToPendingOutcome;
|
||||
pub use runtime::ObserveToPendingRequest;
|
||||
pub use runtime::PendingOutcome;
|
||||
pub use runtime::RuntimeResponse;
|
||||
pub use runtime::WaitOutcome;
|
||||
pub use runtime::WaitRequest;
|
||||
pub use runtime::WaitToPendingOutcome;
|
||||
pub use runtime::WaitToPendingRequest;
|
||||
pub use session::CellId;
|
||||
pub use session::CodeModeSession;
|
||||
pub use session::CodeModeSessionDelegate;
|
||||
@@ -38,7 +38,6 @@ pub use session::CodeModeSessionProvider;
|
||||
pub use session::CodeModeSessionProviderFuture;
|
||||
pub use session::CodeModeSessionResultFuture;
|
||||
pub use session::NotificationFuture;
|
||||
pub use session::StartedCell;
|
||||
pub use session::ToolInvocationFuture;
|
||||
|
||||
pub const PUBLIC_TOOL_NAME: &str = "exec";
|
||||
|
||||
@@ -13,33 +13,31 @@ pub const DEFAULT_WAIT_YIELD_TIME_MS: u64 = 10_000;
|
||||
pub const DEFAULT_MAX_OUTPUT_TOKENS_PER_EXEC_CALL: usize = 10_000;
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
|
||||
pub struct ExecuteRequest {
|
||||
pub struct CreateCellRequest {
|
||||
pub tool_call_id: String,
|
||||
pub enabled_tools: Vec<ToolDefinition>,
|
||||
pub source: String,
|
||||
pub yield_time_ms: Option<u64>,
|
||||
pub max_output_tokens: Option<usize>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
|
||||
pub struct WaitRequest {
|
||||
pub struct ObserveRequest {
|
||||
pub cell_id: CellId,
|
||||
pub yield_time_ms: u64,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
|
||||
pub struct WaitToPendingRequest {
|
||||
pub struct ObserveToPendingRequest {
|
||||
pub cell_id: CellId,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, PartialEq, Serialize)]
|
||||
pub enum WaitOutcome {
|
||||
pub enum CellOutcome {
|
||||
LiveCell(RuntimeResponse),
|
||||
MissingCell(RuntimeResponse),
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, PartialEq, Serialize)]
|
||||
pub enum ExecuteToPendingOutcome {
|
||||
pub enum PendingOutcome {
|
||||
Pending {
|
||||
cell_id: CellId,
|
||||
content_items: Vec<FunctionCallOutputContentItem>,
|
||||
@@ -49,15 +47,15 @@ pub enum ExecuteToPendingOutcome {
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, PartialEq, Serialize)]
|
||||
pub enum WaitToPendingOutcome {
|
||||
LiveCell(ExecuteToPendingOutcome),
|
||||
pub enum ObserveToPendingOutcome {
|
||||
LiveCell(PendingOutcome),
|
||||
MissingCell(RuntimeResponse),
|
||||
}
|
||||
|
||||
impl From<WaitOutcome> for RuntimeResponse {
|
||||
fn from(outcome: WaitOutcome) -> Self {
|
||||
impl From<CellOutcome> for RuntimeResponse {
|
||||
fn from(outcome: CellOutcome) -> Self {
|
||||
match outcome {
|
||||
WaitOutcome::LiveCell(response) | WaitOutcome::MissingCell(response) => response,
|
||||
CellOutcome::LiveCell(response) | CellOutcome::MissingCell(response) => response,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -87,3 +85,7 @@ pub struct CodeModeNestedToolCall {
|
||||
pub tool_kind: CodeModeToolKind,
|
||||
pub input: Option<JsonValue>,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "runtime_tests.rs"]
|
||||
mod tests;
|
||||
|
||||
@@ -0,0 +1,301 @@
|
||||
use std::fmt::Debug;
|
||||
|
||||
use codex_protocol::ToolName;
|
||||
use pretty_assertions::assert_eq;
|
||||
use serde::Serialize;
|
||||
use serde::de::DeserializeOwned;
|
||||
use serde_json::Value as JsonValue;
|
||||
use serde_json::json;
|
||||
|
||||
use super::*;
|
||||
use crate::ImageDetail;
|
||||
|
||||
fn assert_json_round_trip<T>(value: &T, expected: JsonValue)
|
||||
where
|
||||
T: Debug + DeserializeOwned + PartialEq + Serialize,
|
||||
{
|
||||
assert_eq!(serde_json::to_value(value).unwrap(), expected);
|
||||
assert_eq!(&serde_json::from_value::<T>(expected).unwrap(), value);
|
||||
}
|
||||
|
||||
fn text(value: &str) -> FunctionCallOutputContentItem {
|
||||
FunctionCallOutputContentItem::InputText {
|
||||
text: value.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
fn image(image_url: &str, detail: Option<ImageDetail>) -> FunctionCallOutputContentItem {
|
||||
FunctionCallOutputContentItem::InputImage {
|
||||
image_url: image_url.to_string(),
|
||||
detail,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn requests_round_trip_with_exact_tool_and_namespace_fields() {
|
||||
let create = CreateCellRequest {
|
||||
tool_call_id: "response-call-7".to_string(),
|
||||
enabled_tools: vec![
|
||||
ToolDefinition {
|
||||
name: "mcp__search__query".to_string(),
|
||||
tool_name: ToolName::namespaced("search", "query"),
|
||||
description: "Search indexed documents".to_string(),
|
||||
kind: CodeModeToolKind::Function,
|
||||
input_schema: Some(json!({
|
||||
"type": "object",
|
||||
"properties": {"q": {"type": "string"}},
|
||||
})),
|
||||
output_schema: None,
|
||||
},
|
||||
ToolDefinition {
|
||||
name: "apply_patch".to_string(),
|
||||
tool_name: ToolName::plain("apply_patch"),
|
||||
description: "Apply a patch".to_string(),
|
||||
kind: CodeModeToolKind::Freeform,
|
||||
input_schema: None,
|
||||
output_schema: Some(json!({"type": "string"})),
|
||||
},
|
||||
],
|
||||
source: "await tools.mcp__search__query({ q: 'rust' });".to_string(),
|
||||
};
|
||||
assert_json_round_trip(
|
||||
&create,
|
||||
json!({
|
||||
"tool_call_id": "response-call-7",
|
||||
"enabled_tools": [
|
||||
{
|
||||
"name": "mcp__search__query",
|
||||
"tool_name": {"name": "query", "namespace": "search"},
|
||||
"description": "Search indexed documents",
|
||||
"kind": "function",
|
||||
"input_schema": {
|
||||
"type": "object",
|
||||
"properties": {"q": {"type": "string"}},
|
||||
},
|
||||
"output_schema": null,
|
||||
},
|
||||
{
|
||||
"name": "apply_patch",
|
||||
"tool_name": {"name": "apply_patch", "namespace": null},
|
||||
"description": "Apply a patch",
|
||||
"kind": "freeform",
|
||||
"input_schema": null,
|
||||
"output_schema": {"type": "string"},
|
||||
},
|
||||
],
|
||||
"source": "await tools.mcp__search__query({ q: 'rust' });",
|
||||
}),
|
||||
);
|
||||
|
||||
assert_json_round_trip(
|
||||
&ObserveRequest {
|
||||
cell_id: CellId::new("cell-a7".to_string()),
|
||||
yield_time_ms: 250,
|
||||
},
|
||||
json!({"cell_id": "cell-a7", "yield_time_ms": 250}),
|
||||
);
|
||||
assert_json_round_trip(
|
||||
&ObserveToPendingRequest {
|
||||
cell_id: CellId::new("cell-b9".to_string()),
|
||||
},
|
||||
json!({"cell_id": "cell-b9"}),
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nested_tool_calls_round_trip_with_optional_input_and_tool_kind() {
|
||||
assert_json_round_trip(
|
||||
&CodeModeNestedToolCall {
|
||||
cell_id: CellId::new("cell-a7".to_string()),
|
||||
runtime_tool_call_id: "runtime-call-1".to_string(),
|
||||
tool_name: ToolName::namespaced("search", "query"),
|
||||
tool_kind: CodeModeToolKind::Function,
|
||||
input: Some(json!({"q": "rust"})),
|
||||
},
|
||||
json!({
|
||||
"cell_id": "cell-a7",
|
||||
"runtime_tool_call_id": "runtime-call-1",
|
||||
"tool_name": {"name": "query", "namespace": "search"},
|
||||
"tool_kind": "function",
|
||||
"input": {"q": "rust"},
|
||||
}),
|
||||
);
|
||||
assert_json_round_trip(
|
||||
&CodeModeNestedToolCall {
|
||||
cell_id: CellId::new("cell-b9".to_string()),
|
||||
runtime_tool_call_id: "runtime-call-2".to_string(),
|
||||
tool_name: ToolName::plain("apply_patch"),
|
||||
tool_kind: CodeModeToolKind::Freeform,
|
||||
input: None,
|
||||
},
|
||||
json!({
|
||||
"cell_id": "cell-b9",
|
||||
"runtime_tool_call_id": "runtime-call-2",
|
||||
"tool_name": {"name": "apply_patch", "namespace": null},
|
||||
"tool_kind": "freeform",
|
||||
"input": null,
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runtime_responses_round_trip_with_every_output_and_terminal_variant() {
|
||||
let yielded = RuntimeResponse::Yielded {
|
||||
cell_id: CellId::new("cell-a7".to_string()),
|
||||
content_items: vec![
|
||||
text("before"),
|
||||
image("data:image/png;base64,auto", Some(ImageDetail::Auto)),
|
||||
image("data:image/png;base64,low", Some(ImageDetail::Low)),
|
||||
image("data:image/png;base64,high", Some(ImageDetail::High)),
|
||||
image(
|
||||
"data:image/png;base64,original",
|
||||
Some(ImageDetail::Original),
|
||||
),
|
||||
image("data:image/png;base64,default", None),
|
||||
],
|
||||
};
|
||||
assert_json_round_trip(
|
||||
&yielded,
|
||||
json!({
|
||||
"Yielded": {
|
||||
"cell_id": "cell-a7",
|
||||
"content_items": [
|
||||
{"type": "input_text", "text": "before"},
|
||||
{"type": "input_image", "image_url": "data:image/png;base64,auto", "detail": "auto"},
|
||||
{"type": "input_image", "image_url": "data:image/png;base64,low", "detail": "low"},
|
||||
{"type": "input_image", "image_url": "data:image/png;base64,high", "detail": "high"},
|
||||
{"type": "input_image", "image_url": "data:image/png;base64,original", "detail": "original"},
|
||||
{"type": "input_image", "image_url": "data:image/png;base64,default"},
|
||||
],
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_json_round_trip(
|
||||
&RuntimeResponse::Terminated {
|
||||
cell_id: CellId::new("cell-b9".to_string()),
|
||||
content_items: vec![text("partial")],
|
||||
},
|
||||
json!({
|
||||
"Terminated": {
|
||||
"cell_id": "cell-b9",
|
||||
"content_items": [{"type": "input_text", "text": "partial"}],
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_json_round_trip(
|
||||
&RuntimeResponse::Result {
|
||||
cell_id: CellId::new("cell-c3".to_string()),
|
||||
content_items: vec![text("failed")],
|
||||
error_text: Some("tool failed".to_string()),
|
||||
},
|
||||
json!({
|
||||
"Result": {
|
||||
"cell_id": "cell-c3",
|
||||
"content_items": [{"type": "input_text", "text": "failed"}],
|
||||
"error_text": "tool failed",
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_json_round_trip(
|
||||
&RuntimeResponse::Result {
|
||||
cell_id: CellId::new("cell-d4".to_string()),
|
||||
content_items: Vec::new(),
|
||||
error_text: None,
|
||||
},
|
||||
json!({
|
||||
"Result": {
|
||||
"cell_id": "cell-d4",
|
||||
"content_items": [],
|
||||
"error_text": null,
|
||||
},
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn observation_outcomes_round_trip_with_live_missing_pending_and_completed_cells() {
|
||||
let result = RuntimeResponse::Result {
|
||||
cell_id: CellId::new("cell-a7".to_string()),
|
||||
content_items: vec![text("done")],
|
||||
error_text: None,
|
||||
};
|
||||
assert_json_round_trip(
|
||||
&CellOutcome::LiveCell(result.clone()),
|
||||
json!({
|
||||
"LiveCell": {
|
||||
"Result": {
|
||||
"cell_id": "cell-a7",
|
||||
"content_items": [{"type": "input_text", "text": "done"}],
|
||||
"error_text": null,
|
||||
},
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_json_round_trip(
|
||||
&CellOutcome::MissingCell(RuntimeResponse::Terminated {
|
||||
cell_id: CellId::new("missing".to_string()),
|
||||
content_items: Vec::new(),
|
||||
}),
|
||||
json!({
|
||||
"MissingCell": {
|
||||
"Terminated": {"cell_id": "missing", "content_items": []},
|
||||
},
|
||||
}),
|
||||
);
|
||||
|
||||
let pending = PendingOutcome::Pending {
|
||||
cell_id: CellId::new("cell-b9".to_string()),
|
||||
content_items: vec![text("waiting")],
|
||||
pending_tool_call_ids: vec!["runtime-call-1".to_string()],
|
||||
};
|
||||
assert_json_round_trip(
|
||||
&pending,
|
||||
json!({
|
||||
"Pending": {
|
||||
"cell_id": "cell-b9",
|
||||
"content_items": [{"type": "input_text", "text": "waiting"}],
|
||||
"pending_tool_call_ids": ["runtime-call-1"],
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_json_round_trip(
|
||||
&PendingOutcome::Completed(result),
|
||||
json!({
|
||||
"Completed": {
|
||||
"Result": {
|
||||
"cell_id": "cell-a7",
|
||||
"content_items": [{"type": "input_text", "text": "done"}],
|
||||
"error_text": null,
|
||||
},
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_json_round_trip(
|
||||
&ObserveToPendingOutcome::LiveCell(pending),
|
||||
json!({
|
||||
"LiveCell": {
|
||||
"Pending": {
|
||||
"cell_id": "cell-b9",
|
||||
"content_items": [{"type": "input_text", "text": "waiting"}],
|
||||
"pending_tool_call_ids": ["runtime-call-1"],
|
||||
},
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert_json_round_trip(
|
||||
&ObserveToPendingOutcome::MissingCell(RuntimeResponse::Result {
|
||||
cell_id: CellId::new("missing".to_string()),
|
||||
content_items: Vec::new(),
|
||||
error_text: Some("cell not found".to_string()),
|
||||
}),
|
||||
json!({
|
||||
"MissingCell": {
|
||||
"Result": {
|
||||
"cell_id": "missing",
|
||||
"content_items": [],
|
||||
"error_text": "cell not found",
|
||||
},
|
||||
},
|
||||
}),
|
||||
);
|
||||
}
|
||||
@@ -6,14 +6,12 @@ use std::sync::Arc;
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
use serde_json::Value as JsonValue;
|
||||
use tokio::sync::oneshot;
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use crate::CellOutcome;
|
||||
use crate::CodeModeNestedToolCall;
|
||||
use crate::ExecuteRequest;
|
||||
use crate::RuntimeResponse;
|
||||
use crate::WaitOutcome;
|
||||
use crate::WaitRequest;
|
||||
use crate::CreateCellRequest;
|
||||
use crate::ObserveRequest;
|
||||
|
||||
pub type CodeModeSessionResultFuture<'a, T> =
|
||||
Pin<Box<dyn Future<Output = Result<T, String>> + Send + 'a>>;
|
||||
@@ -48,42 +46,6 @@ impl fmt::Display for CellId {
|
||||
}
|
||||
}
|
||||
|
||||
pub struct StartedCell {
|
||||
pub cell_id: CellId,
|
||||
initial_response: CodeModeSessionResultFuture<'static, RuntimeResponse>,
|
||||
}
|
||||
|
||||
impl StartedCell {
|
||||
pub fn new(cell_id: CellId, initial_response_rx: oneshot::Receiver<RuntimeResponse>) -> Self {
|
||||
Self {
|
||||
cell_id,
|
||||
initial_response: Box::pin(async move {
|
||||
initial_response_rx
|
||||
.await
|
||||
.map_err(|_| "exec runtime ended unexpectedly".to_string())
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn from_result_receiver(
|
||||
cell_id: CellId,
|
||||
initial_response_rx: oneshot::Receiver<Result<RuntimeResponse, String>>,
|
||||
) -> Self {
|
||||
Self {
|
||||
cell_id,
|
||||
initial_response: Box::pin(async move {
|
||||
initial_response_rx
|
||||
.await
|
||||
.map_err(|_| "exec runtime ended unexpectedly".to_string())?
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn initial_response(self) -> Result<RuntimeResponse, String> {
|
||||
self.initial_response.await
|
||||
}
|
||||
}
|
||||
|
||||
/// Host callbacks used by a code-mode session while cells are executing.
|
||||
pub trait CodeModeSessionDelegate: Send + Sync {
|
||||
fn invoke_tool<'a>(
|
||||
@@ -104,11 +66,13 @@ pub trait CodeModeSessionDelegate: Send + Sync {
|
||||
fn cell_closed(&self, cell_id: &CellId);
|
||||
}
|
||||
|
||||
/// A durable code-mode session owned by one Codex thread.
|
||||
/// A stateful code-mode session owned by one Codex thread.
|
||||
///
|
||||
/// Cells executed in the same session share stored values. Separate sessions
|
||||
/// must keep those values isolated. Implementations may execute cells
|
||||
/// in-process or remotely.
|
||||
/// in-process or remotely. Implementations should surface lost connections or
|
||||
/// protocol desynchronization, but do not need to preserve cells or stored
|
||||
/// values across process failure or restart.
|
||||
pub trait CodeModeSession: Send + Sync {
|
||||
/// Returns whether the session can still accept requests.
|
||||
///
|
||||
@@ -116,14 +80,17 @@ pub trait CodeModeSession: Send + Sync {
|
||||
/// connection fails so callers can create a fresh session for later work.
|
||||
fn is_alive(&self) -> bool;
|
||||
|
||||
fn execute<'a>(
|
||||
fn create_cell<'a>(
|
||||
&'a self,
|
||||
request: ExecuteRequest,
|
||||
) -> CodeModeSessionResultFuture<'a, StartedCell>;
|
||||
request: CreateCellRequest,
|
||||
) -> CodeModeSessionResultFuture<'a, CellId>;
|
||||
|
||||
fn wait<'a>(&'a self, request: WaitRequest) -> CodeModeSessionResultFuture<'a, WaitOutcome>;
|
||||
fn observe<'a>(
|
||||
&'a self,
|
||||
request: ObserveRequest,
|
||||
) -> CodeModeSessionResultFuture<'a, CellOutcome>;
|
||||
|
||||
fn terminate<'a>(&'a self, cell_id: CellId) -> CodeModeSessionResultFuture<'a, WaitOutcome>;
|
||||
fn terminate<'a>(&'a self, cell_id: CellId) -> CodeModeSessionResultFuture<'a, CellOutcome>;
|
||||
|
||||
fn shutdown<'a>(&'a self) -> CodeModeSessionResultFuture<'a, ()>;
|
||||
}
|
||||
@@ -138,7 +105,3 @@ pub trait CodeModeSessionProvider: Send + Sync {
|
||||
delegate: Arc<dyn CodeModeSessionDelegate>,
|
||||
) -> CodeModeSessionProviderFuture<'a>;
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "session_tests.rs"]
|
||||
mod tests;
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
use pretty_assertions::assert_eq;
|
||||
use tokio::sync::oneshot;
|
||||
|
||||
use super::CellId;
|
||||
use super::StartedCell;
|
||||
|
||||
#[tokio::test]
|
||||
async fn started_cell_preserves_remote_initial_response_errors() {
|
||||
let (response_tx, response_rx) = oneshot::channel();
|
||||
response_tx
|
||||
.send(Err("remote runtime failed".to_string()))
|
||||
.expect("initial response receiver should be open");
|
||||
let started = StartedCell::from_result_receiver(CellId::new("1".to_string()), response_rx);
|
||||
|
||||
assert_eq!(
|
||||
started.initial_response().await,
|
||||
Err("remote runtime failed".to_string())
|
||||
);
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
use codex_code_mode_protocol::CodeModeToolKind;
|
||||
use codex_code_mode_protocol::ExecuteRequest;
|
||||
use codex_code_mode_protocol::CreateCellRequest;
|
||||
use codex_code_mode_protocol::FunctionCallOutputContentItem;
|
||||
use codex_code_mode_protocol::ImageDetail;
|
||||
use codex_code_mode_protocol::ToolDefinition;
|
||||
@@ -10,8 +10,8 @@ use crate::session_runtime::ImageDetail as CellImageDetail;
|
||||
use crate::session_runtime::OutputItem as CellOutputItem;
|
||||
use crate::session_runtime::ToolKind as CellToolKind;
|
||||
|
||||
pub(super) fn runtime_request(request: CellRequest) -> ExecuteRequest {
|
||||
ExecuteRequest {
|
||||
pub(super) fn runtime_request(request: CellRequest) -> CreateCellRequest {
|
||||
CreateCellRequest {
|
||||
tool_call_id: request.tool_call_id,
|
||||
enabled_tools: request
|
||||
.enabled_tools
|
||||
@@ -32,8 +32,6 @@ pub(super) fn runtime_request(request: CellRequest) -> ExecuteRequest {
|
||||
})
|
||||
.collect(),
|
||||
source: request.source,
|
||||
yield_time_ms: None,
|
||||
max_output_tokens: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -5,7 +5,7 @@ use std::sync::atomic::Ordering;
|
||||
use std::sync::mpsc as std_mpsc;
|
||||
use std::time::Duration;
|
||||
|
||||
use codex_code_mode_protocol::ExecuteRequest;
|
||||
use codex_code_mode_protocol::CreateCellRequest;
|
||||
use codex_code_mode_protocol::FunctionCallOutputContentItem;
|
||||
use pretty_assertions::assert_eq;
|
||||
use serde_json::Value as JsonValue;
|
||||
@@ -109,12 +109,10 @@ fn spawn_cell_actor_harness_with_host<H: CellHost>(host: Arc<H>) -> CellActorHar
|
||||
let (runtime_event_tx, runtime_event_rx) = mpsc::unbounded_channel();
|
||||
let (runtime_tx, runtime_pause_tx, runtime_terminate_handle) = spawn_runtime(
|
||||
HashMap::new(),
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
tool_call_id: "call-1".to_string(),
|
||||
enabled_tools: Vec::new(),
|
||||
source: "await new Promise(() => {});".to_string(),
|
||||
yield_time_ms: None,
|
||||
max_output_tokens: None,
|
||||
},
|
||||
runtime_event_tx,
|
||||
PendingRuntimeMode::PauseUntilResumed,
|
||||
|
||||
@@ -10,8 +10,8 @@ use std::sync::mpsc as std_mpsc;
|
||||
use std::thread;
|
||||
|
||||
use codex_code_mode_protocol::CodeModeToolKind;
|
||||
use codex_code_mode_protocol::CreateCellRequest;
|
||||
use codex_code_mode_protocol::EnabledToolMetadata;
|
||||
use codex_code_mode_protocol::ExecuteRequest;
|
||||
use codex_code_mode_protocol::FunctionCallOutputContentItem;
|
||||
use codex_code_mode_protocol::enabled_tool_metadata;
|
||||
use codex_protocol::ToolName;
|
||||
@@ -67,7 +67,7 @@ pub(crate) enum RuntimeEvent {
|
||||
|
||||
pub(crate) fn spawn_runtime(
|
||||
stored_values: HashMap<String, JsonValue>,
|
||||
request: ExecuteRequest,
|
||||
request: CreateCellRequest,
|
||||
event_tx: mpsc::UnboundedSender<RuntimeEvent>,
|
||||
pending_mode: PendingRuntimeMode,
|
||||
) -> Result<
|
||||
@@ -330,7 +330,7 @@ mod tests {
|
||||
use pretty_assertions::assert_eq;
|
||||
use tokio::sync::mpsc;
|
||||
|
||||
use super::ExecuteRequest;
|
||||
use super::CreateCellRequest;
|
||||
use super::PendingRuntimeMode;
|
||||
use super::RuntimeCommand;
|
||||
use super::RuntimeControlCommand;
|
||||
@@ -338,13 +338,11 @@ mod tests {
|
||||
use super::spawn_runtime;
|
||||
use crate::FunctionCallOutputContentItem;
|
||||
|
||||
fn execute_request(source: &str) -> ExecuteRequest {
|
||||
ExecuteRequest {
|
||||
fn execute_request(source: &str) -> CreateCellRequest {
|
||||
CreateCellRequest {
|
||||
tool_call_id: "call_1".to_string(),
|
||||
enabled_tools: Vec::new(),
|
||||
source: source.to_string(),
|
||||
yield_time_ms: Some(1),
|
||||
max_output_tokens: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2,6 +2,7 @@ use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use codex_code_mode_protocol::CellId;
|
||||
use codex_code_mode_protocol::CellOutcome;
|
||||
use codex_code_mode_protocol::CodeModeNestedToolCall;
|
||||
use codex_code_mode_protocol::CodeModeSession;
|
||||
use codex_code_mode_protocol::CodeModeSessionDelegate;
|
||||
@@ -9,21 +10,17 @@ use codex_code_mode_protocol::CodeModeSessionProvider;
|
||||
use codex_code_mode_protocol::CodeModeSessionProviderFuture;
|
||||
use codex_code_mode_protocol::CodeModeSessionResultFuture;
|
||||
use codex_code_mode_protocol::CodeModeToolKind;
|
||||
use codex_code_mode_protocol::DEFAULT_EXEC_YIELD_TIME_MS;
|
||||
use codex_code_mode_protocol::ExecuteRequest;
|
||||
use codex_code_mode_protocol::ExecuteToPendingOutcome;
|
||||
use codex_code_mode_protocol::CreateCellRequest;
|
||||
use codex_code_mode_protocol::FunctionCallOutputContentItem;
|
||||
use codex_code_mode_protocol::ImageDetail;
|
||||
use codex_code_mode_protocol::NotificationFuture;
|
||||
use codex_code_mode_protocol::ObserveRequest;
|
||||
use codex_code_mode_protocol::ObserveToPendingOutcome;
|
||||
use codex_code_mode_protocol::ObserveToPendingRequest;
|
||||
use codex_code_mode_protocol::PendingOutcome;
|
||||
use codex_code_mode_protocol::RuntimeResponse;
|
||||
use codex_code_mode_protocol::StartedCell;
|
||||
use codex_code_mode_protocol::ToolInvocationFuture;
|
||||
use codex_code_mode_protocol::WaitOutcome;
|
||||
use codex_code_mode_protocol::WaitRequest;
|
||||
use codex_code_mode_protocol::WaitToPendingOutcome;
|
||||
use codex_code_mode_protocol::WaitToPendingRequest;
|
||||
use serde_json::Value as JsonValue;
|
||||
use tokio::sync::oneshot;
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use crate::session_runtime as runtime;
|
||||
@@ -87,62 +84,24 @@ impl CodeModeService {
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn execute(&self, request: ExecuteRequest) -> Result<StartedCell, String> {
|
||||
let yield_time_ms = request.yield_time_ms.unwrap_or(DEFAULT_EXEC_YIELD_TIME_MS);
|
||||
pub async fn create_cell(&self, request: CreateCellRequest) -> Result<CellId, String> {
|
||||
let runtime_cell_id = self
|
||||
.runtime
|
||||
.create_cell(runtime_request(request))
|
||||
.await
|
||||
.map_err(|error| error.to_string())?;
|
||||
let pending_event = self
|
||||
.runtime
|
||||
.begin_observe(
|
||||
&runtime_cell_id,
|
||||
runtime::ObserveMode::YieldAfter(Duration::from_millis(yield_time_ms)),
|
||||
)
|
||||
.await
|
||||
.map_err(|error| error.to_string())?;
|
||||
let cell_id = protocol_cell_id(&runtime_cell_id);
|
||||
let response_cell_id = cell_id.clone();
|
||||
let (response_tx, response_rx) = oneshot::channel();
|
||||
tokio::spawn(async move {
|
||||
let response = pending_event
|
||||
.event()
|
||||
.await
|
||||
.map_err(|error| error.to_string())
|
||||
.and_then(|event| runtime_response(&response_cell_id, event));
|
||||
let _ = response_tx.send(response);
|
||||
});
|
||||
Ok(StartedCell::from_result_receiver(cell_id, response_rx))
|
||||
Ok(protocol_cell_id(&runtime_cell_id))
|
||||
}
|
||||
|
||||
pub async fn execute_to_pending(
|
||||
pub async fn observe(&self, request: ObserveRequest) -> Result<CellOutcome, String> {
|
||||
self.begin_observe(request).await.await
|
||||
}
|
||||
|
||||
async fn begin_observe(
|
||||
&self,
|
||||
request: ExecuteRequest,
|
||||
) -> Result<ExecuteToPendingOutcome, String> {
|
||||
let runtime_cell_id = self
|
||||
.runtime
|
||||
.create_cell(runtime_request(request))
|
||||
.await
|
||||
.map_err(|error| error.to_string())?;
|
||||
let cell_id = protocol_cell_id(&runtime_cell_id);
|
||||
let event = self
|
||||
.runtime
|
||||
.observe(&runtime_cell_id, runtime::ObserveMode::PendingFrontier)
|
||||
.await
|
||||
.map_err(|error| error.to_string())?;
|
||||
pending_outcome(&cell_id, event)
|
||||
}
|
||||
|
||||
pub async fn wait(&self, request: WaitRequest) -> Result<WaitOutcome, String> {
|
||||
self.begin_wait(request).await.await
|
||||
}
|
||||
|
||||
async fn begin_wait(
|
||||
&self,
|
||||
request: WaitRequest,
|
||||
) -> CodeModeSessionResultFuture<'static, WaitOutcome> {
|
||||
let WaitRequest {
|
||||
request: ObserveRequest,
|
||||
) -> CodeModeSessionResultFuture<'static, CellOutcome> {
|
||||
let ObserveRequest {
|
||||
cell_id,
|
||||
yield_time_ms,
|
||||
} = request;
|
||||
@@ -157,34 +116,34 @@ impl CodeModeService {
|
||||
{
|
||||
Ok(pending_event) => Box::pin(async move {
|
||||
match pending_event.event().await {
|
||||
Ok(event) => Ok(WaitOutcome::LiveCell(runtime_response(&cell_id, event)?)),
|
||||
Ok(event) => Ok(CellOutcome::LiveCell(runtime_response(&cell_id, event)?)),
|
||||
Err(runtime::Error::MissingCell(_) | runtime::Error::ClosedCell(_)) => {
|
||||
Ok(WaitOutcome::MissingCell(missing_cell_response(cell_id)))
|
||||
Ok(CellOutcome::MissingCell(missing_cell_response(cell_id)))
|
||||
}
|
||||
Err(error) => Err(error.to_string()),
|
||||
}
|
||||
}),
|
||||
Err(runtime::Error::MissingCell(_) | runtime::Error::ClosedCell(_)) => {
|
||||
missing_wait(cell_id)
|
||||
missing_observation(cell_id)
|
||||
}
|
||||
Err(error) => Box::pin(async move { Err(error.to_string()) }),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn terminate(&self, cell_id: CellId) -> Result<WaitOutcome, String> {
|
||||
pub async fn terminate(&self, cell_id: CellId) -> Result<CellOutcome, String> {
|
||||
match self.runtime.terminate(&runtime_cell_id(&cell_id)).await {
|
||||
Ok(event) => Ok(WaitOutcome::LiveCell(runtime_response(&cell_id, event)?)),
|
||||
Ok(event) => Ok(CellOutcome::LiveCell(runtime_response(&cell_id, event)?)),
|
||||
Err(runtime::Error::MissingCell(_) | runtime::Error::ClosedCell(_)) => {
|
||||
Ok(WaitOutcome::MissingCell(missing_cell_response(cell_id)))
|
||||
Ok(CellOutcome::MissingCell(missing_cell_response(cell_id)))
|
||||
}
|
||||
Err(error) => Err(error.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn wait_to_pending(
|
||||
pub async fn observe_to_pending(
|
||||
&self,
|
||||
request: WaitToPendingRequest,
|
||||
) -> Result<WaitToPendingOutcome, String> {
|
||||
request: ObserveToPendingRequest,
|
||||
) -> Result<ObserveToPendingOutcome, String> {
|
||||
let cell_id = request.cell_id;
|
||||
match self
|
||||
.runtime
|
||||
@@ -194,11 +153,11 @@ impl CodeModeService {
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(event) => Ok(WaitToPendingOutcome::LiveCell(pending_outcome(
|
||||
Ok(event) => Ok(ObserveToPendingOutcome::LiveCell(pending_outcome(
|
||||
&cell_id, event,
|
||||
)?)),
|
||||
Err(runtime::Error::MissingCell(_) | runtime::Error::ClosedCell(_)) => Ok(
|
||||
WaitToPendingOutcome::MissingCell(missing_cell_response(cell_id)),
|
||||
ObserveToPendingOutcome::MissingCell(missing_cell_response(cell_id)),
|
||||
),
|
||||
Err(error) => Err(error.to_string()),
|
||||
}
|
||||
@@ -223,18 +182,21 @@ impl CodeModeSession for CodeModeService {
|
||||
self.runtime.is_alive()
|
||||
}
|
||||
|
||||
fn execute<'a>(
|
||||
fn create_cell<'a>(
|
||||
&'a self,
|
||||
request: ExecuteRequest,
|
||||
) -> CodeModeSessionResultFuture<'a, StartedCell> {
|
||||
Box::pin(CodeModeService::execute(self, request))
|
||||
request: CreateCellRequest,
|
||||
) -> CodeModeSessionResultFuture<'a, CellId> {
|
||||
Box::pin(CodeModeService::create_cell(self, request))
|
||||
}
|
||||
|
||||
fn wait<'a>(&'a self, request: WaitRequest) -> CodeModeSessionResultFuture<'a, WaitOutcome> {
|
||||
Box::pin(CodeModeService::wait(self, request))
|
||||
fn observe<'a>(
|
||||
&'a self,
|
||||
request: ObserveRequest,
|
||||
) -> CodeModeSessionResultFuture<'a, CellOutcome> {
|
||||
Box::pin(CodeModeService::observe(self, request))
|
||||
}
|
||||
|
||||
fn terminate<'a>(&'a self, cell_id: CellId) -> CodeModeSessionResultFuture<'a, WaitOutcome> {
|
||||
fn terminate<'a>(&'a self, cell_id: CellId) -> CodeModeSessionResultFuture<'a, CellOutcome> {
|
||||
Box::pin(CodeModeService::terminate(self, cell_id))
|
||||
}
|
||||
|
||||
@@ -295,7 +257,7 @@ impl runtime::SessionRuntimeDelegate for ProtocolDelegate {
|
||||
}
|
||||
}
|
||||
|
||||
fn runtime_request(request: ExecuteRequest) -> runtime::CreateCellRequest {
|
||||
fn runtime_request(request: CreateCellRequest) -> runtime::CreateCellRequest {
|
||||
runtime::CreateCellRequest {
|
||||
tool_call_id: request.tool_call_id,
|
||||
enabled_tools: request
|
||||
@@ -326,22 +288,17 @@ fn protocol_cell_id(cell_id: &runtime::CellId) -> CellId {
|
||||
CellId::new(cell_id.as_str().to_string())
|
||||
}
|
||||
|
||||
fn pending_outcome(
|
||||
cell_id: &CellId,
|
||||
event: runtime::CellEvent,
|
||||
) -> Result<ExecuteToPendingOutcome, String> {
|
||||
fn pending_outcome(cell_id: &CellId, event: runtime::CellEvent) -> Result<PendingOutcome, String> {
|
||||
match event {
|
||||
runtime::CellEvent::Pending {
|
||||
content_items,
|
||||
pending_tool_call_ids,
|
||||
} => Ok(ExecuteToPendingOutcome::Pending {
|
||||
} => Ok(PendingOutcome::Pending {
|
||||
cell_id: cell_id.clone(),
|
||||
content_items: content_items.into_iter().map(output_item).collect(),
|
||||
pending_tool_call_ids,
|
||||
}),
|
||||
event => Ok(ExecuteToPendingOutcome::Completed(runtime_response(
|
||||
cell_id, event,
|
||||
)?)),
|
||||
event => Ok(PendingOutcome::Completed(runtime_response(cell_id, event)?)),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -397,8 +354,8 @@ fn missing_cell_response(cell_id: CellId) -> RuntimeResponse {
|
||||
}
|
||||
}
|
||||
|
||||
fn missing_wait(cell_id: CellId) -> CodeModeSessionResultFuture<'static, WaitOutcome> {
|
||||
Box::pin(async move { Ok(WaitOutcome::MissingCell(missing_cell_response(cell_id))) })
|
||||
fn missing_observation(cell_id: CellId) -> CodeModeSessionResultFuture<'static, CellOutcome> {
|
||||
Box::pin(async move { Ok(CellOutcome::MissingCell(missing_cell_response(cell_id))) })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -178,13 +178,45 @@ fn cell_id(value: &str) -> CellId {
|
||||
CellId::new(value.to_string())
|
||||
}
|
||||
|
||||
fn execute_request(source: &str) -> ExecuteRequest {
|
||||
ExecuteRequest {
|
||||
fn execute_request(source: &str) -> CreateCellRequest {
|
||||
CreateCellRequest {
|
||||
tool_call_id: "call-1".to_string(),
|
||||
enabled_tools: Vec::new(),
|
||||
source: source.to_string(),
|
||||
yield_time_ms: Some(1),
|
||||
max_output_tokens: None,
|
||||
}
|
||||
}
|
||||
|
||||
async fn execute(service: &CodeModeService, request: CreateCellRequest) -> RuntimeResponse {
|
||||
execute_with_yield_time(service, request, /*yield_time_ms*/ 1).await
|
||||
}
|
||||
|
||||
async fn execute_with_yield_time(
|
||||
service: &CodeModeService,
|
||||
request: CreateCellRequest,
|
||||
yield_time_ms: u64,
|
||||
) -> RuntimeResponse {
|
||||
let cell_id = service.create_cell(request).await.unwrap();
|
||||
service
|
||||
.observe(ObserveRequest {
|
||||
cell_id,
|
||||
yield_time_ms,
|
||||
})
|
||||
.await
|
||||
.unwrap()
|
||||
.into()
|
||||
}
|
||||
|
||||
async fn create_and_observe_to_pending(
|
||||
service: &CodeModeService,
|
||||
request: CreateCellRequest,
|
||||
) -> Result<PendingOutcome, String> {
|
||||
let cell_id = service.create_cell(request).await?;
|
||||
match service
|
||||
.observe_to_pending(ObserveToPendingRequest { cell_id })
|
||||
.await?
|
||||
{
|
||||
ObserveToPendingOutcome::LiveCell(outcome) => Ok(outcome),
|
||||
ObserveToPendingOutcome::MissingCell(response) => Ok(PendingOutcome::Completed(response)),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -209,17 +241,18 @@ async fn next_event(events_rx: &mut mpsc::UnboundedReceiver<DelegateEvent>) -> D
|
||||
#[tokio::test]
|
||||
async fn yields_and_resumes() {
|
||||
let service = CodeModeService::new();
|
||||
let cell = service
|
||||
.execute(ExecuteRequest {
|
||||
let cell = execute_with_yield_time(
|
||||
&service,
|
||||
CreateCellRequest {
|
||||
source: r#"text("before"); yield_control(); text("after");"#.to_string(),
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request("")
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
},
|
||||
/*yield_time_ms*/ 60_000,
|
||||
)
|
||||
.await;
|
||||
|
||||
assert_eq!(
|
||||
cell.initial_response().await.unwrap(),
|
||||
cell,
|
||||
RuntimeResponse::Yielded {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
@@ -229,13 +262,13 @@ async fn yields_and_resumes() {
|
||||
);
|
||||
assert_eq!(
|
||||
service
|
||||
.wait(WaitRequest {
|
||||
.observe(ObserveRequest {
|
||||
cell_id: cell_id("1"),
|
||||
yield_time_ms: 60_000,
|
||||
})
|
||||
.await
|
||||
.unwrap(),
|
||||
WaitOutcome::LiveCell(RuntimeResponse::Result {
|
||||
CellOutcome::LiveCell(RuntimeResponse::Result {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "after".to_string(),
|
||||
@@ -251,20 +284,21 @@ async fn returns_and_resumes_from_the_pending_frontier() {
|
||||
let service = CodeModeService::with_delegate(delegate.clone());
|
||||
|
||||
assert_eq!(
|
||||
service
|
||||
.execute_to_pending(ExecuteRequest {
|
||||
create_and_observe_to_pending(
|
||||
&service,
|
||||
CreateCellRequest {
|
||||
enabled_tools: vec![blocking_tool()],
|
||||
source: r#"
|
||||
await tools.block({});
|
||||
text("after");
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request("")
|
||||
})
|
||||
.await
|
||||
.unwrap(),
|
||||
ExecuteToPendingOutcome::Pending {
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap(),
|
||||
PendingOutcome::Pending {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
pending_tool_call_ids: vec!["tool-1".to_string()],
|
||||
@@ -276,53 +310,51 @@ text("after");
|
||||
|
||||
assert_eq!(
|
||||
service
|
||||
.wait_to_pending(WaitToPendingRequest {
|
||||
.observe_to_pending(ObserveToPendingRequest {
|
||||
cell_id: cell_id("1"),
|
||||
})
|
||||
.await
|
||||
.unwrap(),
|
||||
WaitToPendingOutcome::LiveCell(ExecuteToPendingOutcome::Completed(
|
||||
RuntimeResponse::Result {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "after".to_string(),
|
||||
}],
|
||||
error_text: None,
|
||||
}
|
||||
))
|
||||
ObserveToPendingOutcome::LiveCell(PendingOutcome::Completed(RuntimeResponse::Result {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "after".to_string(),
|
||||
}],
|
||||
error_text: None,
|
||||
}))
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn observed_natural_completion_wins_over_termination() {
|
||||
let service = CodeModeService::new();
|
||||
let cell = service
|
||||
.execute(execute_request(
|
||||
r#"yield_control(); store("finished", true); text("done");"#,
|
||||
))
|
||||
.await
|
||||
.unwrap();
|
||||
let cell = execute(
|
||||
&service,
|
||||
execute_request(r#"yield_control(); store("finished", true); text("done");"#),
|
||||
)
|
||||
.await;
|
||||
|
||||
assert_eq!(
|
||||
cell.initial_response().await.unwrap(),
|
||||
cell,
|
||||
RuntimeResponse::Yielded {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
}
|
||||
);
|
||||
tokio::time::timeout(Duration::from_secs(1), async {
|
||||
tokio::time::timeout(Duration::from_secs(10), async {
|
||||
loop {
|
||||
let response = service
|
||||
.execute(ExecuteRequest {
|
||||
yield_time_ms: Some(60_000),
|
||||
// Observe the synchronous probe through completion so scheduler load
|
||||
// cannot turn its short yield deadline into a false lifecycle failure.
|
||||
let response = create_and_observe_to_pending(
|
||||
&service,
|
||||
CreateCellRequest {
|
||||
..execute_request(r#"text(String(load("finished")));"#)
|
||||
})
|
||||
.await
|
||||
.unwrap()
|
||||
.initial_response()
|
||||
.await
|
||||
.unwrap();
|
||||
let RuntimeResponse::Result { content_items, .. } = response else {
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let PendingOutcome::Completed(RuntimeResponse::Result { content_items, .. }) = response
|
||||
else {
|
||||
panic!("expected stored-value probe to complete");
|
||||
};
|
||||
if content_items
|
||||
@@ -339,7 +371,7 @@ async fn observed_natural_completion_wins_over_termination() {
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
service.terminate(cell_id("1")).await.unwrap(),
|
||||
WaitOutcome::LiveCell(RuntimeResponse::Result {
|
||||
CellOutcome::LiveCell(RuntimeResponse::Result {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "done".to_string(),
|
||||
@@ -353,19 +385,18 @@ async fn observed_natural_completion_wins_over_termination() {
|
||||
async fn termination_discards_pending_callbacks_before_responding() {
|
||||
let (delegate, mut events_rx) = BlockingDelegate::new();
|
||||
let service = CodeModeService::with_delegate(delegate.clone());
|
||||
let cell = service
|
||||
.execute(execute_request(
|
||||
r#"notify("pending"); await new Promise(() => {});"#,
|
||||
))
|
||||
.await
|
||||
.unwrap();
|
||||
let cell = execute(
|
||||
&service,
|
||||
execute_request(r#"notify("pending"); await new Promise(() => {});"#),
|
||||
)
|
||||
.await;
|
||||
|
||||
assert_eq!(
|
||||
next_event(&mut events_rx).await,
|
||||
DelegateEvent::NotificationStarted
|
||||
);
|
||||
assert_eq!(
|
||||
cell.initial_response().await.unwrap(),
|
||||
cell,
|
||||
RuntimeResponse::Yielded {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
@@ -373,7 +404,7 @@ async fn termination_discards_pending_callbacks_before_responding() {
|
||||
);
|
||||
assert_eq!(
|
||||
service.terminate(cell_id("1")).await.unwrap(),
|
||||
WaitOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
CellOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
})
|
||||
@@ -388,15 +419,14 @@ async fn termination_discards_pending_callbacks_before_responding() {
|
||||
async fn termination_discards_stored_writes_before_the_next_cell_can_load_them() {
|
||||
let (delegate, mut events_rx) = BlockingDelegate::new();
|
||||
let service = CodeModeService::with_delegate(delegate.clone());
|
||||
let cell = service
|
||||
.execute(ExecuteRequest {
|
||||
let created_cell_id = service
|
||||
.create_cell(CreateCellRequest {
|
||||
enabled_tools: vec![blocking_tool()],
|
||||
source: r#"
|
||||
store("candidate", "leaked");
|
||||
await tools.block({});
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request("")
|
||||
})
|
||||
.await
|
||||
@@ -405,8 +435,8 @@ await tools.block({});
|
||||
// Reaching the delegate proves that the store ran before execution became gated.
|
||||
assert_eq!(next_event(&mut events_rx).await, DelegateEvent::ToolStarted);
|
||||
assert_eq!(
|
||||
service.terminate(cell.cell_id).await.unwrap(),
|
||||
WaitOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
service.terminate(created_cell_id).await.unwrap(),
|
||||
CellOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
})
|
||||
@@ -418,16 +448,12 @@ await tools.block({});
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
service
|
||||
.execute(ExecuteRequest {
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request(r#"text(String(load("candidate")));"#)
|
||||
})
|
||||
.await
|
||||
.unwrap()
|
||||
.initial_response()
|
||||
.await
|
||||
.unwrap(),
|
||||
execute_with_yield_time(
|
||||
&service,
|
||||
execute_request(r#"text(String(load("candidate")));"#),
|
||||
/*yield_time_ms*/ 60_000,
|
||||
)
|
||||
.await,
|
||||
RuntimeResponse::Result {
|
||||
cell_id: cell_id("2"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
@@ -443,7 +469,7 @@ async fn shutdown_does_not_await_notifications_during_natural_completion() {
|
||||
let (delegate, mut events_rx) = NeverResolvingNotificationDelegate::new();
|
||||
let service = Arc::new(CodeModeService::with_delegate(delegate));
|
||||
service
|
||||
.execute(execute_request(r#"notify("pending");"#))
|
||||
.create_cell(execute_request(r#"notify("pending");"#))
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
@@ -469,8 +495,8 @@ async fn shutdown_does_not_await_notifications_during_natural_completion() {
|
||||
async fn shutdown_does_not_await_a_non_cooperative_nested_tool() {
|
||||
let (delegate, mut events_rx) = NeverResolvingToolDelegate::new();
|
||||
let service = CodeModeService::with_delegate(delegate);
|
||||
let _started = service
|
||||
.execute(ExecuteRequest {
|
||||
let _cell_id = service
|
||||
.create_cell(CreateCellRequest {
|
||||
enabled_tools: vec![blocking_tool()],
|
||||
source: r#"await tools.block({});"#.to_string(),
|
||||
..execute_request("")
|
||||
@@ -493,19 +519,18 @@ async fn shutdown_does_not_await_a_non_cooperative_nested_tool() {
|
||||
async fn termination_does_not_await_a_non_cooperative_notification() {
|
||||
let (delegate, mut events_rx) = NeverResolvingNotificationDelegate::new();
|
||||
let service = CodeModeService::with_delegate(delegate);
|
||||
let cell = service
|
||||
.execute(execute_request(
|
||||
r#"notify("pending"); await new Promise(() => {});"#,
|
||||
))
|
||||
.await
|
||||
.unwrap();
|
||||
let cell = execute(
|
||||
&service,
|
||||
execute_request(r#"notify("pending"); await new Promise(() => {});"#),
|
||||
)
|
||||
.await;
|
||||
|
||||
assert_eq!(
|
||||
next_event(&mut events_rx).await,
|
||||
DelegateEvent::NotificationStarted
|
||||
);
|
||||
assert_eq!(
|
||||
cell.initial_response().await.unwrap(),
|
||||
cell,
|
||||
RuntimeResponse::Yielded {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
@@ -520,7 +545,7 @@ async fn termination_does_not_await_a_non_cooperative_notification() {
|
||||
.await
|
||||
.expect("termination should not await a non-cooperative notification")
|
||||
.unwrap(),
|
||||
WaitOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
CellOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
})
|
||||
@@ -534,13 +559,10 @@ async fn termination_does_not_await_a_non_cooperative_notification() {
|
||||
#[tokio::test]
|
||||
async fn second_observer_is_rejected_without_displacing_the_first() {
|
||||
let service = CodeModeService::new();
|
||||
let cell = service
|
||||
.execute(execute_request("await new Promise(() => {});"))
|
||||
.await
|
||||
.unwrap();
|
||||
let cell = execute(&service, execute_request("await new Promise(() => {});")).await;
|
||||
|
||||
assert_eq!(
|
||||
cell.initial_response().await.unwrap(),
|
||||
cell,
|
||||
RuntimeResponse::Yielded {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
@@ -548,14 +570,14 @@ async fn second_observer_is_rejected_without_displacing_the_first() {
|
||||
);
|
||||
|
||||
let first_observer = service
|
||||
.begin_wait(WaitRequest {
|
||||
.begin_observe(ObserveRequest {
|
||||
cell_id: cell_id("1"),
|
||||
yield_time_ms: 60_000,
|
||||
})
|
||||
.await;
|
||||
assert_eq!(
|
||||
service
|
||||
.wait(WaitRequest {
|
||||
.observe(ObserveRequest {
|
||||
cell_id: cell_id("1"),
|
||||
yield_time_ms: 60_000,
|
||||
})
|
||||
@@ -570,11 +592,11 @@ async fn second_observer_is_rejected_without_displacing_the_first() {
|
||||
};
|
||||
assert_eq!(
|
||||
service.terminate(cell_id("1")).await.unwrap(),
|
||||
WaitOutcome::LiveCell(terminated.clone())
|
||||
CellOutcome::LiveCell(terminated.clone())
|
||||
);
|
||||
assert_eq!(
|
||||
first_observer.await.unwrap(),
|
||||
WaitOutcome::LiveCell(terminated)
|
||||
CellOutcome::LiveCell(terminated)
|
||||
);
|
||||
}
|
||||
|
||||
@@ -582,8 +604,8 @@ async fn second_observer_is_rejected_without_displacing_the_first() {
|
||||
async fn natural_completion_cleans_up_callbacks_before_responding() {
|
||||
let (delegate, mut events_rx) = BlockingDelegate::new();
|
||||
let service = CodeModeService::with_delegate(delegate.clone());
|
||||
let cell = service
|
||||
.execute(ExecuteRequest {
|
||||
let created_cell_id = service
|
||||
.create_cell(CreateCellRequest {
|
||||
enabled_tools: vec![blocking_tool()],
|
||||
source: concat!(
|
||||
"tools.block({});",
|
||||
@@ -591,7 +613,6 @@ async fn natural_completion_cleans_up_callbacks_before_responding() {
|
||||
"text('done');",
|
||||
)
|
||||
.to_string(),
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request("")
|
||||
})
|
||||
.await
|
||||
@@ -599,14 +620,20 @@ async fn natural_completion_cleans_up_callbacks_before_responding() {
|
||||
|
||||
assert_eq!(next_event(&mut events_rx).await, DelegateEvent::ToolStarted);
|
||||
assert_eq!(
|
||||
cell.initial_response().await.unwrap(),
|
||||
RuntimeResponse::Result {
|
||||
service
|
||||
.observe(ObserveRequest {
|
||||
cell_id: created_cell_id,
|
||||
yield_time_ms: 60_000,
|
||||
})
|
||||
.await
|
||||
.unwrap(),
|
||||
CellOutcome::LiveCell(RuntimeResponse::Result {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "done".to_string(),
|
||||
}],
|
||||
error_text: None,
|
||||
}
|
||||
})
|
||||
);
|
||||
assert!(delegate.tool_future_dropped.load(Ordering::Acquire));
|
||||
}
|
||||
|
||||
@@ -2,20 +2,20 @@ use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use super::CellId;
|
||||
use super::CellOutcome;
|
||||
use super::CodeModeNestedToolCall;
|
||||
use super::CodeModeService;
|
||||
use super::CodeModeSessionDelegate;
|
||||
use super::NotificationFuture;
|
||||
use super::ObserveRequest;
|
||||
use super::ObserveToPendingOutcome;
|
||||
use super::ObserveToPendingRequest;
|
||||
use super::RuntimeResponse;
|
||||
use super::ToolInvocationFuture;
|
||||
use super::WaitOutcome;
|
||||
use super::WaitRequest;
|
||||
use super::WaitToPendingOutcome;
|
||||
use super::WaitToPendingRequest;
|
||||
use crate::CodeModeToolKind;
|
||||
use crate::ExecuteRequest;
|
||||
use crate::ExecuteToPendingOutcome;
|
||||
use crate::CreateCellRequest;
|
||||
use crate::FunctionCallOutputContentItem;
|
||||
use crate::PendingOutcome;
|
||||
use crate::ToolDefinition;
|
||||
use codex_protocol::ToolName;
|
||||
use pretty_assertions::assert_eq;
|
||||
@@ -61,13 +61,11 @@ impl CodeModeSessionDelegate for ReleasableToolDelegate {
|
||||
fn cell_closed(&self, _cell_id: &CellId) {}
|
||||
}
|
||||
|
||||
fn execute_request(source: &str) -> ExecuteRequest {
|
||||
ExecuteRequest {
|
||||
fn execute_request(source: &str) -> CreateCellRequest {
|
||||
CreateCellRequest {
|
||||
tool_call_id: "call_1".to_string(),
|
||||
enabled_tools: Vec::new(),
|
||||
source: source.to_string(),
|
||||
yield_time_ms: Some(1),
|
||||
max_output_tokens: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -86,14 +84,38 @@ fn echo_tool() -> ToolDefinition {
|
||||
}
|
||||
}
|
||||
|
||||
async fn execute(service: &CodeModeService, request: ExecuteRequest) -> RuntimeResponse {
|
||||
async fn execute(service: &CodeModeService, request: CreateCellRequest) -> RuntimeResponse {
|
||||
execute_with_yield_time(service, request, /*yield_time_ms*/ 10_000).await
|
||||
}
|
||||
|
||||
async fn execute_with_yield_time(
|
||||
service: &CodeModeService,
|
||||
request: CreateCellRequest,
|
||||
yield_time_ms: u64,
|
||||
) -> RuntimeResponse {
|
||||
let cell_id = service.create_cell(request).await.unwrap();
|
||||
service
|
||||
.execute(request)
|
||||
.await
|
||||
.unwrap()
|
||||
.initial_response()
|
||||
.observe(ObserveRequest {
|
||||
cell_id,
|
||||
yield_time_ms,
|
||||
})
|
||||
.await
|
||||
.unwrap()
|
||||
.into()
|
||||
}
|
||||
|
||||
async fn create_and_observe_to_pending(
|
||||
service: &CodeModeService,
|
||||
request: CreateCellRequest,
|
||||
) -> Result<PendingOutcome, String> {
|
||||
let cell_id = service.create_cell(request).await?;
|
||||
match service
|
||||
.observe_to_pending(ObserveToPendingRequest { cell_id })
|
||||
.await?
|
||||
{
|
||||
ObserveToPendingOutcome::LiveCell(outcome) => Ok(outcome),
|
||||
ObserveToPendingOutcome::MissingCell(response) => Ok(PendingOutcome::Completed(response)),
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
@@ -102,9 +124,8 @@ async fn synchronous_exit_returns_successfully() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"text("before"); exit(); text("after");"#.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -129,9 +150,8 @@ async fn stored_values_are_shared_between_cells_but_not_sessions() {
|
||||
|
||||
let write_response = execute(
|
||||
&first_session,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"store("key", "visible");"#.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -139,18 +159,16 @@ async fn stored_values_are_shared_between_cells_but_not_sessions() {
|
||||
|
||||
let same_session = execute(
|
||||
&first_session,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"text(String(load("key")));"#.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
.await;
|
||||
let other_session = execute(
|
||||
&second_session,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"text(String(load("key")));"#.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -190,15 +208,17 @@ async fn stored_values_are_shared_between_cells_but_not_sessions() {
|
||||
async fn shutdown_interrupts_cpu_bound_cells() {
|
||||
let service = CodeModeService::new();
|
||||
|
||||
let cell = service
|
||||
.execute(ExecuteRequest {
|
||||
let response = execute_with_yield_time(
|
||||
&service,
|
||||
CreateCellRequest {
|
||||
source: "while (true) {}".to_string(),
|
||||
..execute_request("")
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
},
|
||||
/*yield_time_ms*/ 1,
|
||||
)
|
||||
.await;
|
||||
assert_eq!(
|
||||
cell.initial_response().await.unwrap(),
|
||||
response,
|
||||
RuntimeResponse::Yielded {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
@@ -217,7 +237,7 @@ async fn start_cell_rejects_new_cell_after_shutdown_begins() {
|
||||
service.shutdown().await.unwrap();
|
||||
|
||||
let error = service
|
||||
.execute(execute_request("text('late');"))
|
||||
.create_cell(execute_request("text('late');"))
|
||||
.await
|
||||
.err()
|
||||
.unwrap();
|
||||
@@ -226,21 +246,22 @@ async fn start_cell_rejects_new_cell_after_shutdown_begins() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_to_pending_returns_completed_for_synchronous_results() {
|
||||
async fn create_and_observe_to_pending_returns_completed_for_synchronous_results() {
|
||||
let service = CodeModeService::new();
|
||||
|
||||
let response = service
|
||||
.execute_to_pending(ExecuteRequest {
|
||||
let response = create_and_observe_to_pending(
|
||||
&service,
|
||||
CreateCellRequest {
|
||||
source: r#"text("done");"#.to_string(),
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request("")
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
response,
|
||||
ExecuteToPendingOutcome::Completed(RuntimeResponse::Result {
|
||||
PendingOutcome::Completed(RuntimeResponse::Result {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "done".to_string(),
|
||||
@@ -251,16 +272,18 @@ async fn execute_to_pending_returns_completed_for_synchronous_results() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_to_pending_returns_once_the_runtime_is_quiescent() {
|
||||
async fn create_and_observe_to_pending_returns_once_the_runtime_is_quiescent() {
|
||||
let service = CodeModeService::new();
|
||||
|
||||
let response = tokio::time::timeout(
|
||||
Duration::from_secs(1),
|
||||
service.execute_to_pending(ExecuteRequest {
|
||||
source: r#"text("before"); await new Promise(() => {});"#.to_string(),
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request("")
|
||||
}),
|
||||
create_and_observe_to_pending(
|
||||
&service,
|
||||
CreateCellRequest {
|
||||
source: r#"text("before"); await new Promise(() => {});"#.to_string(),
|
||||
..execute_request("")
|
||||
},
|
||||
),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
@@ -268,7 +291,7 @@ async fn execute_to_pending_returns_once_the_runtime_is_quiescent() {
|
||||
|
||||
assert_eq!(
|
||||
response,
|
||||
ExecuteToPendingOutcome::Pending {
|
||||
PendingOutcome::Pending {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "before".to_string(),
|
||||
@@ -281,7 +304,7 @@ async fn execute_to_pending_returns_once_the_runtime_is_quiescent() {
|
||||
|
||||
assert_eq!(
|
||||
termination,
|
||||
WaitOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
CellOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
})
|
||||
@@ -289,11 +312,12 @@ async fn execute_to_pending_returns_once_the_runtime_is_quiescent() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_to_pending_identifies_tool_calls_in_paused_frontier() {
|
||||
async fn create_and_observe_to_pending_identifies_tool_calls_in_paused_frontier() {
|
||||
let service = CodeModeService::new();
|
||||
|
||||
let response = service
|
||||
.execute_to_pending(ExecuteRequest {
|
||||
let response = create_and_observe_to_pending(
|
||||
&service,
|
||||
CreateCellRequest {
|
||||
enabled_tools: vec![echo_tool()],
|
||||
source: r#"
|
||||
await Promise.all([
|
||||
@@ -302,15 +326,15 @@ await Promise.all([
|
||||
]);
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request("")
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
response,
|
||||
ExecuteToPendingOutcome::Pending {
|
||||
PendingOutcome::Pending {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
pending_tool_call_ids: vec!["tool-1".to_string(), "tool-2".to_string()],
|
||||
@@ -321,7 +345,7 @@ await Promise.all([
|
||||
|
||||
assert_eq!(
|
||||
termination,
|
||||
WaitOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
CellOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
})
|
||||
@@ -329,11 +353,12 @@ await Promise.all([
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn execute_to_pending_excludes_delayed_timeout_tool_calls_until_wait() {
|
||||
async fn create_and_observe_to_pending_excludes_delayed_timeout_tool_calls_until_observe() {
|
||||
let service = CodeModeService::new();
|
||||
|
||||
let initial_response = service
|
||||
.execute_to_pending(ExecuteRequest {
|
||||
let initial_response = create_and_observe_to_pending(
|
||||
&service,
|
||||
CreateCellRequest {
|
||||
enabled_tools: vec![echo_tool()],
|
||||
source: r#"
|
||||
setTimeout(() => {
|
||||
@@ -345,15 +370,15 @@ await Promise.all([
|
||||
]);
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request("")
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
initial_response,
|
||||
ExecuteToPendingOutcome::Pending {
|
||||
PendingOutcome::Pending {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
pending_tool_call_ids: vec!["tool-1".to_string(), "tool-2".to_string()],
|
||||
@@ -367,13 +392,13 @@ await Promise.all([
|
||||
let resumed_response = tokio::time::timeout(Duration::from_secs(5), async {
|
||||
loop {
|
||||
let response = service
|
||||
.wait_to_pending(WaitToPendingRequest {
|
||||
.observe_to_pending(ObserveToPendingRequest {
|
||||
cell_id: cell_id("1"),
|
||||
})
|
||||
.await?;
|
||||
if !matches!(
|
||||
&response,
|
||||
WaitToPendingOutcome::LiveCell(ExecuteToPendingOutcome::Pending {
|
||||
ObserveToPendingOutcome::LiveCell(PendingOutcome::Pending {
|
||||
pending_tool_call_ids,
|
||||
..
|
||||
}) if pending_tool_call_ids.is_empty()
|
||||
@@ -388,7 +413,7 @@ await Promise.all([
|
||||
|
||||
assert_eq!(
|
||||
resumed_response,
|
||||
WaitToPendingOutcome::LiveCell(ExecuteToPendingOutcome::Pending {
|
||||
ObserveToPendingOutcome::LiveCell(PendingOutcome::Pending {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
pending_tool_call_ids: vec!["tool-3".to_string()],
|
||||
@@ -399,7 +424,7 @@ await Promise.all([
|
||||
|
||||
assert_eq!(
|
||||
termination,
|
||||
WaitOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
CellOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
})
|
||||
@@ -407,12 +432,13 @@ await Promise.all([
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn wait_to_pending_returns_after_resumed_runtime_becomes_quiescent_again() {
|
||||
async fn observe_to_pending_returns_after_resumed_runtime_becomes_quiescent_again() {
|
||||
let delegate = Arc::new(ReleasableToolDelegate::default());
|
||||
let service = CodeModeService::with_delegate(delegate.clone());
|
||||
|
||||
let initial_response = service
|
||||
.execute_to_pending(ExecuteRequest {
|
||||
let initial_response = create_and_observe_to_pending(
|
||||
&service,
|
||||
CreateCellRequest {
|
||||
enabled_tools: vec![echo_tool()],
|
||||
source: r#"
|
||||
await tools.echo({});
|
||||
@@ -420,15 +446,15 @@ text("after");
|
||||
await new Promise(() => {});
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request("")
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
initial_response,
|
||||
ExecuteToPendingOutcome::Pending {
|
||||
PendingOutcome::Pending {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
pending_tool_call_ids: vec!["tool-1".to_string()],
|
||||
@@ -439,7 +465,7 @@ await new Promise(() => {});
|
||||
|
||||
let resumed_response = tokio::time::timeout(
|
||||
Duration::from_secs(1),
|
||||
service.wait_to_pending(WaitToPendingRequest {
|
||||
service.observe_to_pending(ObserveToPendingRequest {
|
||||
cell_id: cell_id("1"),
|
||||
}),
|
||||
)
|
||||
@@ -449,7 +475,7 @@ await new Promise(() => {});
|
||||
|
||||
assert_eq!(
|
||||
resumed_response,
|
||||
WaitToPendingOutcome::LiveCell(ExecuteToPendingOutcome::Pending {
|
||||
ObserveToPendingOutcome::LiveCell(PendingOutcome::Pending {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "after".to_string(),
|
||||
@@ -462,7 +488,7 @@ await new Promise(() => {});
|
||||
|
||||
assert_eq!(
|
||||
termination,
|
||||
WaitOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
CellOutcome::LiveCell(RuntimeResponse::Terminated {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
})
|
||||
@@ -470,27 +496,28 @@ await new Promise(() => {});
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn wait_to_pending_returns_completed_after_resumed_runtime_finishes() {
|
||||
async fn observe_to_pending_returns_completed_after_resumed_runtime_finishes() {
|
||||
let delegate = Arc::new(ReleasableToolDelegate::default());
|
||||
let service = CodeModeService::with_delegate(delegate.clone());
|
||||
|
||||
let initial_response = service
|
||||
.execute_to_pending(ExecuteRequest {
|
||||
let initial_response = create_and_observe_to_pending(
|
||||
&service,
|
||||
CreateCellRequest {
|
||||
enabled_tools: vec![echo_tool()],
|
||||
source: r#"
|
||||
await tools.echo({});
|
||||
text("done");
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: Some(60_000),
|
||||
..execute_request("")
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
initial_response,
|
||||
ExecuteToPendingOutcome::Pending {
|
||||
PendingOutcome::Pending {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: Vec::new(),
|
||||
pending_tool_call_ids: vec!["tool-1".to_string()],
|
||||
@@ -501,7 +528,7 @@ text("done");
|
||||
|
||||
let resumed_response = tokio::time::timeout(
|
||||
Duration::from_secs(1),
|
||||
service.wait_to_pending(WaitToPendingRequest {
|
||||
service.observe_to_pending(ObserveToPendingRequest {
|
||||
cell_id: cell_id("1"),
|
||||
}),
|
||||
)
|
||||
@@ -511,15 +538,13 @@ text("done");
|
||||
|
||||
assert_eq!(
|
||||
resumed_response,
|
||||
WaitToPendingOutcome::LiveCell(ExecuteToPendingOutcome::Completed(
|
||||
RuntimeResponse::Result {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "done".to_string(),
|
||||
}],
|
||||
error_text: None,
|
||||
}
|
||||
))
|
||||
ObserveToPendingOutcome::LiveCell(PendingOutcome::Completed(RuntimeResponse::Result {
|
||||
cell_id: cell_id("1"),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "done".to_string(),
|
||||
}],
|
||||
error_text: None,
|
||||
}))
|
||||
);
|
||||
}
|
||||
|
||||
@@ -529,9 +554,8 @@ async fn v8_console_is_not_exposed_on_global_this() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"text(String(Object.hasOwn(globalThis, "console")));"#.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -555,7 +579,7 @@ async fn date_locale_string_formats_with_icu_data() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"
|
||||
const value = new Date("2025-01-02T03:04:05Z")
|
||||
.toLocaleString("fr-FR", {
|
||||
@@ -571,7 +595,6 @@ const value = new Date("2025-01-02T03:04:05Z")
|
||||
text(value);
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -595,7 +618,7 @@ async fn intl_date_time_format_formats_with_icu_data() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"
|
||||
const formatter = new Intl.DateTimeFormat("fr-FR", {
|
||||
weekday: "long",
|
||||
@@ -610,7 +633,6 @@ const formatter = new Intl.DateTimeFormat("fr-FR", {
|
||||
text(formatter.format(new Date("2025-01-02T03:04:05Z")));
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -634,7 +656,7 @@ async fn output_helpers_return_undefined() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"
|
||||
const returnsUndefined = [
|
||||
text("first"),
|
||||
@@ -644,7 +666,6 @@ const returnsUndefined = [
|
||||
text(JSON.stringify(returnsUndefined));
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -677,7 +698,7 @@ async fn image_helper_accepts_raw_mcp_image_block_with_original_detail() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"
|
||||
image({
|
||||
type: "image",
|
||||
@@ -687,7 +708,6 @@ image({
|
||||
});
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -712,7 +732,7 @@ async fn generated_image_helper_appends_image_and_output_hint() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"
|
||||
generatedImage({
|
||||
image_url: "data:image/png;base64,AAA",
|
||||
@@ -720,7 +740,6 @@ generatedImage({
|
||||
});
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -750,7 +769,7 @@ async fn image_helper_second_arg_overrides_explicit_object_detail() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"
|
||||
image(
|
||||
{
|
||||
@@ -761,7 +780,6 @@ image(
|
||||
);
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -786,7 +804,7 @@ async fn image_helper_second_arg_overrides_raw_mcp_image_detail() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"
|
||||
image(
|
||||
{
|
||||
@@ -799,7 +817,6 @@ image(
|
||||
);
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -824,7 +841,7 @@ async fn image_helper_accepts_low_detail() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"
|
||||
image({
|
||||
image_url: "data:image/png;base64,AAA",
|
||||
@@ -832,7 +849,6 @@ image({
|
||||
});
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -865,9 +881,8 @@ async fn image_helpers_reject_remote_urls() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source,
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -893,7 +908,7 @@ async fn image_helper_rejects_unsupported_detail() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"
|
||||
image({
|
||||
image_url: "data:image/png;base64,AAA",
|
||||
@@ -901,7 +916,6 @@ image({
|
||||
});
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -923,7 +937,7 @@ async fn image_helper_rejects_raw_mcp_result_container() {
|
||||
|
||||
let response = execute(
|
||||
&service,
|
||||
ExecuteRequest {
|
||||
CreateCellRequest {
|
||||
source: r#"
|
||||
image({
|
||||
content: [
|
||||
@@ -938,7 +952,6 @@ image({
|
||||
});
|
||||
"#
|
||||
.to_string(),
|
||||
yield_time_ms: None,
|
||||
..execute_request("")
|
||||
},
|
||||
)
|
||||
@@ -957,11 +970,11 @@ image({
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn wait_reports_missing_cell_separately_from_runtime_results() {
|
||||
async fn observe_reports_missing_cell_separately_from_runtime_results() {
|
||||
let service = CodeModeService::new();
|
||||
|
||||
let response = service
|
||||
.wait(WaitRequest {
|
||||
.observe(ObserveRequest {
|
||||
cell_id: cell_id("missing"),
|
||||
yield_time_ms: 1,
|
||||
})
|
||||
@@ -970,7 +983,7 @@ async fn wait_reports_missing_cell_separately_from_runtime_results() {
|
||||
|
||||
assert_eq!(
|
||||
response,
|
||||
WaitOutcome::MissingCell(RuntimeResponse::Result {
|
||||
CellOutcome::MissingCell(RuntimeResponse::Result {
|
||||
cell_id: cell_id("missing"),
|
||||
content_items: Vec::new(),
|
||||
error_text: Some("exec cell missing not found".to_string()),
|
||||
|
||||
@@ -9,6 +9,7 @@ use codex_tools::ToolName;
|
||||
use codex_tools::ToolSpec;
|
||||
|
||||
use super::ExecContext;
|
||||
use super::InitialObservationGuard;
|
||||
use super::PUBLIC_TOOL_NAME;
|
||||
use super::handle_runtime_response;
|
||||
use super::is_exec_tool_name;
|
||||
@@ -39,20 +40,17 @@ impl CodeModeExecuteHandler {
|
||||
let enabled_tools =
|
||||
codex_tools::collect_code_mode_tool_definitions(&self.nested_tool_specs);
|
||||
let started_at = std::time::Instant::now();
|
||||
let started_cell = exec
|
||||
let cell_id = exec
|
||||
.session
|
||||
.services
|
||||
.code_mode_service
|
||||
.execute(codex_code_mode::ExecuteRequest {
|
||||
.create_cell(codex_code_mode::CreateCellRequest {
|
||||
tool_call_id: call_id.clone(),
|
||||
enabled_tools,
|
||||
source: args.code.clone(),
|
||||
yield_time_ms: args.yield_time_ms,
|
||||
max_output_tokens: args.max_output_tokens,
|
||||
})
|
||||
.await
|
||||
.map_err(FunctionCallError::RespondToModel)?;
|
||||
let cell_id = started_cell.cell_id.clone();
|
||||
let runtime_cell_id = cell_id.to_string();
|
||||
let code_cell_trace = exec
|
||||
.session
|
||||
@@ -64,14 +62,34 @@ impl CodeModeExecuteHandler {
|
||||
call_id.as_str(),
|
||||
args.code.as_str(),
|
||||
);
|
||||
let mut initial_observation_guard = InitialObservationGuard::new(
|
||||
&exec.session.services.code_mode_service,
|
||||
cell_id.clone(),
|
||||
code_cell_trace.clone(),
|
||||
)
|
||||
.map_err(FunctionCallError::RespondToModel)?;
|
||||
exec.session
|
||||
.services
|
||||
.code_mode_service
|
||||
.mark_cell_ready_for_dispatch(&cell_id);
|
||||
let response = started_cell
|
||||
.initial_response()
|
||||
.await
|
||||
.map_err(FunctionCallError::RespondToModel)?;
|
||||
let observed = exec
|
||||
.session
|
||||
.services
|
||||
.code_mode_service
|
||||
.observe(codex_code_mode::ObserveRequest {
|
||||
cell_id: cell_id.clone(),
|
||||
yield_time_ms: args
|
||||
.yield_time_ms
|
||||
.unwrap_or(codex_code_mode::DEFAULT_EXEC_YIELD_TIME_MS),
|
||||
})
|
||||
.await;
|
||||
let response: codex_code_mode::RuntimeResponse = match observed {
|
||||
Ok(outcome) => outcome.into(),
|
||||
Err(error) => {
|
||||
initial_observation_guard.finish_with_error(&error);
|
||||
return Err(FunctionCallError::RespondToModel(error));
|
||||
}
|
||||
};
|
||||
// Record the raw runtime boundary. The model-visible custom-tool output
|
||||
// is produced by `handle_runtime_response` and later linked through
|
||||
// `CodeCell.output_item_ids` in the reduced trace.
|
||||
@@ -85,6 +103,7 @@ impl CodeModeExecuteHandler {
|
||||
.code_mode_service
|
||||
.finish_cell_dispatch(&cell_id);
|
||||
}
|
||||
initial_observation_guard.disarm();
|
||||
handle_runtime_response(&exec, response, args.max_output_tokens, started_at)
|
||||
.await
|
||||
.map_err(FunctionCallError::RespondToModel)
|
||||
|
||||
@@ -63,6 +63,63 @@ pub(crate) struct CodeModeService {
|
||||
dispatch_broker: Arc<CodeModeDispatchBroker>,
|
||||
}
|
||||
|
||||
struct InitialObservationGuard {
|
||||
session: Arc<dyn CodeModeSession>,
|
||||
dispatch_broker: Arc<CodeModeDispatchBroker>,
|
||||
cell_id: Option<CellId>,
|
||||
code_cell_trace: codex_rollout_trace::CodeCellTraceContext,
|
||||
}
|
||||
|
||||
impl InitialObservationGuard {
|
||||
fn new(
|
||||
service: &CodeModeService,
|
||||
cell_id: CellId,
|
||||
code_cell_trace: codex_rollout_trace::CodeCellTraceContext,
|
||||
) -> Result<Self, String> {
|
||||
Ok(Self {
|
||||
session: Arc::clone(service.session()?),
|
||||
dispatch_broker: Arc::clone(&service.dispatch_broker),
|
||||
cell_id: Some(cell_id),
|
||||
code_cell_trace,
|
||||
})
|
||||
}
|
||||
|
||||
fn finish_with_error(&mut self, error_text: &str) {
|
||||
let Some(cell_id) = self.cell_id.take() else {
|
||||
return;
|
||||
};
|
||||
let response = RuntimeResponse::Result {
|
||||
cell_id: cell_id.clone(),
|
||||
content_items: Vec::new(),
|
||||
error_text: Some(error_text.to_string()),
|
||||
};
|
||||
self.code_cell_trace.record_initial_response(&response);
|
||||
self.code_cell_trace.record_ended(&response);
|
||||
self.dispatch_broker.close_cell(&cell_id);
|
||||
|
||||
let session = Arc::clone(&self.session);
|
||||
let Ok(runtime) = tokio::runtime::Handle::try_current() else {
|
||||
tracing::warn!("unable to terminate code-mode cell {cell_id}: no Tokio runtime");
|
||||
return;
|
||||
};
|
||||
let _termination_task = runtime.spawn(async move {
|
||||
if let Err(error) = session.terminate(cell_id.clone()).await {
|
||||
tracing::warn!("failed to terminate code-mode cell {cell_id}: {error}");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
fn disarm(&mut self) {
|
||||
self.cell_id = None;
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for InitialObservationGuard {
|
||||
fn drop(&mut self) {
|
||||
self.finish_with_error("initial code-mode observation cancelled");
|
||||
}
|
||||
}
|
||||
|
||||
impl CodeModeService {
|
||||
pub(crate) fn new() -> Self {
|
||||
let dispatch_broker = Arc::new(CodeModeDispatchBroker::new());
|
||||
@@ -74,24 +131,24 @@ impl CodeModeService {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) async fn execute(
|
||||
pub(crate) async fn create_cell(
|
||||
&self,
|
||||
request: codex_code_mode::ExecuteRequest,
|
||||
) -> Result<codex_code_mode::StartedCell, String> {
|
||||
self.session()?.execute(request).await
|
||||
request: codex_code_mode::CreateCellRequest,
|
||||
) -> Result<CellId, String> {
|
||||
self.session()?.create_cell(request).await
|
||||
}
|
||||
|
||||
pub(crate) async fn wait(
|
||||
pub(crate) async fn observe(
|
||||
&self,
|
||||
request: codex_code_mode::WaitRequest,
|
||||
) -> Result<codex_code_mode::WaitOutcome, String> {
|
||||
self.session()?.wait(request).await
|
||||
request: codex_code_mode::ObserveRequest,
|
||||
) -> Result<codex_code_mode::CellOutcome, String> {
|
||||
self.session()?.observe(request).await
|
||||
}
|
||||
|
||||
pub(crate) async fn terminate(
|
||||
&self,
|
||||
cell_id: CellId,
|
||||
) -> Result<codex_code_mode::WaitOutcome, String> {
|
||||
) -> Result<codex_code_mode::CellOutcome, String> {
|
||||
self.session()?.terminate(cell_id).await
|
||||
}
|
||||
|
||||
@@ -322,13 +379,71 @@ fn build_freeform_tool_payload(
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::CodeModeDispatchBroker;
|
||||
use super::InitialObservationGuard;
|
||||
use super::build_nested_tool_payload;
|
||||
use super::truncate_code_mode_result;
|
||||
use crate::tools::context::ToolPayload;
|
||||
use codex_code_mode::CellId;
|
||||
use codex_code_mode::CellOutcome;
|
||||
use codex_code_mode::CodeModeSession;
|
||||
use codex_code_mode::CodeModeSessionResultFuture;
|
||||
use codex_code_mode::CodeModeToolKind;
|
||||
use codex_code_mode::CreateCellRequest;
|
||||
use codex_code_mode::ObserveRequest;
|
||||
use codex_code_mode::RuntimeResponse;
|
||||
use codex_protocol::models::FunctionCallOutputContentItem;
|
||||
use codex_tools::ToolName;
|
||||
use serde_json::json;
|
||||
use std::sync::Arc;
|
||||
use std::sync::Mutex;
|
||||
|
||||
struct RecordingCodeModeSession {
|
||||
terminated_cells: Mutex<Vec<CellId>>,
|
||||
termination: tokio::sync::Notify,
|
||||
}
|
||||
|
||||
impl CodeModeSession for RecordingCodeModeSession {
|
||||
fn is_alive(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn create_cell<'a>(
|
||||
&'a self,
|
||||
_request: CreateCellRequest,
|
||||
) -> CodeModeSessionResultFuture<'a, CellId> {
|
||||
Box::pin(async { panic!("unexpected cell creation") })
|
||||
}
|
||||
|
||||
fn observe<'a>(
|
||||
&'a self,
|
||||
_request: ObserveRequest,
|
||||
) -> CodeModeSessionResultFuture<'a, CellOutcome> {
|
||||
Box::pin(async { panic!("unexpected cell observation") })
|
||||
}
|
||||
|
||||
fn terminate<'a>(
|
||||
&'a self,
|
||||
cell_id: CellId,
|
||||
) -> CodeModeSessionResultFuture<'a, CellOutcome> {
|
||||
Box::pin(async move {
|
||||
self.terminated_cells
|
||||
.lock()
|
||||
.expect("terminated-cell lock should not be poisoned")
|
||||
.push(cell_id.clone());
|
||||
self.termination.notify_one();
|
||||
Ok(CellOutcome::MissingCell(RuntimeResponse::Result {
|
||||
cell_id,
|
||||
content_items: Vec::new(),
|
||||
error_text: Some("terminated by test".to_string()),
|
||||
}))
|
||||
})
|
||||
}
|
||||
|
||||
fn shutdown<'a>(&'a self) -> CodeModeSessionResultFuture<'a, ()> {
|
||||
Box::pin(async { Ok(()) })
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn build_nested_tool_payload_uses_function_kind() {
|
||||
@@ -382,4 +497,39 @@ mod tests {
|
||||
}]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn dropping_initial_observation_guard_terminates_the_cell() {
|
||||
let session = Arc::new(RecordingCodeModeSession {
|
||||
terminated_cells: Mutex::new(Vec::new()),
|
||||
termination: tokio::sync::Notify::new(),
|
||||
});
|
||||
let session_trait: Arc<dyn CodeModeSession> = session.clone();
|
||||
let dispatch_broker = Arc::new(CodeModeDispatchBroker::new());
|
||||
let cell_id = CellId::new("cell-1".to_string());
|
||||
dispatch_broker.mark_cell_ready_for_dispatch(&cell_id);
|
||||
let code_cell_trace = codex_rollout_trace::ThreadTraceContext::disabled()
|
||||
.code_cell_trace_context("turn-1", cell_id.as_str());
|
||||
|
||||
drop(InitialObservationGuard {
|
||||
session: session_trait,
|
||||
dispatch_broker,
|
||||
cell_id: Some(cell_id.clone()),
|
||||
code_cell_trace,
|
||||
});
|
||||
|
||||
tokio::time::timeout(
|
||||
std::time::Duration::from_secs(1),
|
||||
session.termination.notified(),
|
||||
)
|
||||
.await
|
||||
.expect("guard should schedule cell termination");
|
||||
assert_eq!(
|
||||
*session
|
||||
.terminated_cells
|
||||
.lock()
|
||||
.expect("terminated-cell lock should not be poisoned"),
|
||||
vec![cell_id]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -89,14 +89,14 @@ impl CodeModeWaitHandler {
|
||||
exec.session
|
||||
.services
|
||||
.code_mode_service
|
||||
.wait(codex_code_mode::WaitRequest {
|
||||
.observe(codex_code_mode::ObserveRequest {
|
||||
cell_id,
|
||||
yield_time_ms: args.yield_time_ms,
|
||||
})
|
||||
.await
|
||||
}
|
||||
.map_err(FunctionCallError::RespondToModel)?;
|
||||
if let codex_code_mode::WaitOutcome::LiveCell(response) = &wait_response
|
||||
if let codex_code_mode::CellOutcome::LiveCell(response) = &wait_response
|
||||
&& !matches!(response, codex_code_mode::RuntimeResponse::Yielded { .. })
|
||||
{
|
||||
// Only a live-cell wait can close a CodeCell. A missing
|
||||
|
||||
@@ -2530,6 +2530,131 @@ text({ json: true });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn code_mode_exec_observes_a_synchronously_completed_cell() -> Result<()> {
|
||||
skip_if_no_network!(Ok(()));
|
||||
|
||||
let server = responses::start_mock_server().await;
|
||||
let (_test, second_mock) = run_code_mode_turn(
|
||||
&server,
|
||||
"use exec to return immediately",
|
||||
r#"text("created before observation");"#,
|
||||
)
|
||||
.await?;
|
||||
|
||||
let request = second_mock.single_request();
|
||||
let (output, success) = custom_tool_output_body_and_success(&request, "call-1");
|
||||
assert_ne!(
|
||||
success,
|
||||
Some(false),
|
||||
"exec call failed unexpectedly: {output}"
|
||||
);
|
||||
assert_eq!(output, "created before observation");
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg_attr(windows, ignore = "no exec_command on Windows")]
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn interrupting_the_initial_exec_observation_terminates_the_created_cell() -> Result<()> {
|
||||
skip_if_no_network!(Ok(()));
|
||||
|
||||
let server = responses::start_mock_server().await;
|
||||
let mut builder = test_codex().with_config(|config| {
|
||||
let _ = config.features.enable(Feature::CodeMode);
|
||||
});
|
||||
let test = builder.build(&server).await?;
|
||||
let started_marker = test.workspace_path("code-mode-initial-observation-started");
|
||||
let started_marker_quoted = shlex::try_join([started_marker.to_string_lossy().as_ref()])?;
|
||||
let start_command = format!("printf started > {started_marker_quoted}");
|
||||
let code = format!(
|
||||
r#"// @exec: {{"yield_time_ms": 60000}}
|
||||
await tools.exec_command({{ cmd: {start_command:?} }});
|
||||
store("initial_observation_cancel_probe", "leaked");
|
||||
await new Promise((resolve) => setTimeout(resolve, 2000));
|
||||
"#
|
||||
);
|
||||
|
||||
responses::mount_sse_once(
|
||||
&server,
|
||||
sse(vec![
|
||||
ev_response_created("resp-1"),
|
||||
ev_custom_tool_call("call-1", "exec", &code),
|
||||
ev_completed("resp-1"),
|
||||
]),
|
||||
)
|
||||
.await;
|
||||
|
||||
let cwd = test.config.cwd.clone();
|
||||
let (sandbox_policy, permission_profile) =
|
||||
turn_permission_fields(PermissionProfile::Disabled, cwd.as_path());
|
||||
test.codex
|
||||
.submit(Op::UserInput {
|
||||
items: vec![UserInput::Text {
|
||||
text: "start an exec whose initial observation will be interrupted".into(),
|
||||
text_elements: Vec::new(),
|
||||
}],
|
||||
final_output_json_schema: None,
|
||||
responsesapi_client_metadata: None,
|
||||
additional_context: Default::default(),
|
||||
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
|
||||
approval_policy: Some(AskForApproval::Never),
|
||||
sandbox_policy: Some(sandbox_policy),
|
||||
permission_profile,
|
||||
..Default::default()
|
||||
},
|
||||
})
|
||||
.await?;
|
||||
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !started_marker.exists() {
|
||||
tokio::time::sleep(Duration::from_millis(/*millis*/ 10)).await;
|
||||
}
|
||||
})
|
||||
.await?;
|
||||
test.codex.submit(Op::Interrupt).await?;
|
||||
wait_for_event(&test.codex, |event| {
|
||||
matches!(event, EventMsg::TurnAborted(_))
|
||||
})
|
||||
.await;
|
||||
|
||||
// The sentinel is already pending when the observation is interrupted. Without the guard
|
||||
// around create + initial observe, the detached cell finishes this timer and commits it after
|
||||
// the interrupted turn has gone away.
|
||||
tokio::time::sleep(Duration::from_millis(/*millis*/ 2_250)).await;
|
||||
|
||||
responses::mount_sse_once(
|
||||
&server,
|
||||
sse(vec![
|
||||
ev_response_created("resp-2"),
|
||||
ev_custom_tool_call(
|
||||
"call-2",
|
||||
"exec",
|
||||
r#"text(String(load("initial_observation_cancel_probe")));"#,
|
||||
),
|
||||
ev_completed("resp-2"),
|
||||
]),
|
||||
)
|
||||
.await;
|
||||
let probe_completion = responses::mount_sse_once(
|
||||
&server,
|
||||
sse(vec![
|
||||
ev_assistant_message("msg-2", "done"),
|
||||
ev_completed("resp-3"),
|
||||
]),
|
||||
)
|
||||
.await;
|
||||
|
||||
test.submit_turn("check whether the interrupted cell committed state")
|
||||
.await?;
|
||||
let request = probe_completion.single_request();
|
||||
let (output, success) = custom_tool_output_body_and_success(&request, "call-2");
|
||||
assert_ne!(success, Some(false), "probe exec failed: {output}");
|
||||
assert_eq!(output, "undefined");
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn code_mode_can_resume_after_set_timeout() -> Result<()> {
|
||||
skip_if_no_network!(Ok(()));
|
||||
|
||||
Reference in New Issue
Block a user