mirror of
https://github.com/openai/codex.git
synced 2026-05-29 23:40:29 +00:00
768848ab6f
## Summary
Adds experimental `additionalContext` support to `turn/start` and
`turn/steer` so clients can provide ephemeral external context, such as
browser or automation state, without turning that plumbing into a
visible user prompt or triggering user-prompt lifecycle behavior.
## API Shape
The parameter shape is:
```ts
additionalContext?: Record<string, {
value: string
kind: "untrusted" | "application"
}> | null
```
Example:
```json
{
"additionalContext": {
"browser_info": {
"value": "Active tab is CI failures.",
"kind": "untrusted"
},
"automation_info": {
"value": "CI rerun is in progress.",
"kind": "application"
}
}
}
```
The keys are opaque and caller-defined.
## Context Injection
When provided, accepted entries are inserted into model context as
hidden contextual message items, not as visible thread user-message
items.
`kind: "untrusted"` entries are inserted with role `user`:
```text
<external_${key}>${value}</external_${key}>
```
`kind: "application"` entries are inserted with role `developer`:
```text
<${key}>${value}</${key}>
```
Values are not escaped. Each value is truncated to 1k approximate tokens
before wrapping.
For `turn/start`, accepted additional context is inserted before normal
user input. For `turn/steer`, additional context is merged only when the
steer includes non-empty user input; context-only steers still reject as
empty input.
## Dedupe Strategy
`AdditionalContextStore` lives on session state and stores the latest
complete additional-context map.
Each `turn/start` or non-empty `turn/steer` treats its
`additionalContext` as the current complete set of values. Entries are
injected only when the key is new or the exact entry for that key
changed, including `value` or `kind`. After merging, the store is
replaced with the provided map, so omitted keys are removed from the
retained set and can be injected again later if reintroduced.
Omitting `additionalContext`, passing `null`, or passing an empty object
resets the store to empty and injects nothing.
## What Changed
- Threads experimental v2 `additionalContext` through app-server into
core turn start and steer handling.
- Adds separate contextual fragment types for untrusted user-role
context and application developer-role context.
- Uses pending response input items so additional context can be
combined with normal user input without treating it as prompt text.
- Adds integration coverage for start/steer flow, role routing,
dedupe/reset behavior, deletion/re-add behavior, hook-blocked input
behavior, empty context-only steer rejection, external-fragment marker
matching, and truncation.
122 lines
4.4 KiB
Rust
122 lines
4.4 KiB
Rust
#![cfg(not(target_os = "windows"))]
|
||
|
||
use codex_protocol::models::PermissionProfile;
|
||
use codex_protocol::protocol::AskForApproval;
|
||
use codex_protocol::protocol::EventMsg;
|
||
use codex_protocol::protocol::Op;
|
||
use codex_protocol::user_input::UserInput;
|
||
use core_test_support::responses;
|
||
use core_test_support::skip_if_no_network;
|
||
use core_test_support::test_codex::TestCodex;
|
||
use core_test_support::test_codex::test_codex;
|
||
use core_test_support::test_codex::turn_permission_fields;
|
||
use core_test_support::wait_for_event;
|
||
use pretty_assertions::assert_eq;
|
||
use responses::ev_assistant_message;
|
||
use responses::ev_completed;
|
||
use responses::sse;
|
||
use responses::start_mock_server;
|
||
|
||
const SCHEMA: &str = r#"
|
||
{
|
||
"type": "object",
|
||
"properties": {
|
||
"explanation": { "type": "string" },
|
||
"final_answer": { "type": "string" }
|
||
},
|
||
"required": ["explanation", "final_answer"],
|
||
"additionalProperties": false
|
||
}
|
||
"#;
|
||
|
||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||
async fn codex_returns_json_result_for_gpt5() -> anyhow::Result<()> {
|
||
codex_returns_json_result("gpt-5.4".to_string()).await
|
||
}
|
||
|
||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||
async fn codex_returns_json_result_for_gpt5_codex() -> anyhow::Result<()> {
|
||
codex_returns_json_result("gpt-5.4".to_string()).await
|
||
}
|
||
|
||
async fn codex_returns_json_result(model: String) -> anyhow::Result<()> {
|
||
skip_if_no_network!(Ok(()));
|
||
|
||
let server = start_mock_server().await;
|
||
|
||
let sse1 = sse(vec![
|
||
ev_assistant_message(
|
||
"m2",
|
||
r#"{"explanation": "explanation", "final_answer": "final_answer"}"#,
|
||
),
|
||
ev_completed("r1"),
|
||
]);
|
||
|
||
let expected_schema: serde_json::Value = serde_json::from_str(SCHEMA)?;
|
||
let match_json_text_param = move |req: &wiremock::Request| {
|
||
let body: serde_json::Value = serde_json::from_slice(&req.body).unwrap_or_default();
|
||
let Some(text) = body.get("text") else {
|
||
return false;
|
||
};
|
||
let Some(format) = text.get("format") else {
|
||
return false;
|
||
};
|
||
|
||
format.get("name") == Some(&serde_json::Value::String("codex_output_schema".into()))
|
||
&& format.get("type") == Some(&serde_json::Value::String("json_schema".into()))
|
||
&& format.get("strict") == Some(&serde_json::Value::Bool(true))
|
||
&& format.get("schema") == Some(&expected_schema)
|
||
};
|
||
responses::mount_sse_once_match(&server, match_json_text_param, sse1).await;
|
||
|
||
let TestCodex { codex, cwd, .. } = test_codex().build(&server).await?;
|
||
let (sandbox_policy, permission_profile) =
|
||
turn_permission_fields(PermissionProfile::Disabled, cwd.path());
|
||
|
||
// 1) Normal user input – should hit server once.
|
||
codex
|
||
.submit(Op::UserInput {
|
||
items: vec![UserInput::Text {
|
||
text: "hello world".into(),
|
||
text_elements: Vec::new(),
|
||
}],
|
||
environments: None,
|
||
final_output_json_schema: Some(serde_json::from_str(SCHEMA)?),
|
||
responsesapi_client_metadata: None,
|
||
additional_context: Default::default(),
|
||
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
|
||
cwd: Some(cwd.path().to_path_buf()),
|
||
approval_policy: Some(AskForApproval::Never),
|
||
sandbox_policy: Some(sandbox_policy),
|
||
permission_profile,
|
||
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
|
||
mode: codex_protocol::config_types::ModeKind::Default,
|
||
settings: codex_protocol::config_types::Settings {
|
||
model,
|
||
reasoning_effort: None,
|
||
developer_instructions: None,
|
||
},
|
||
}),
|
||
..Default::default()
|
||
},
|
||
})
|
||
.await?;
|
||
|
||
let message = wait_for_event(&codex, |ev| matches!(ev, EventMsg::AgentMessage(_))).await;
|
||
if let EventMsg::AgentMessage(message) = message {
|
||
let json: serde_json::Value = serde_json::from_str(&message.message)?;
|
||
assert_eq!(
|
||
json.get("explanation"),
|
||
Some(&serde_json::Value::String("explanation".into()))
|
||
);
|
||
assert_eq!(
|
||
json.get("final_answer"),
|
||
Some(&serde_json::Value::String("final_answer".into()))
|
||
);
|
||
} else {
|
||
anyhow::bail!("expected agent message event");
|
||
}
|
||
|
||
Ok(())
|
||
}
|