2b96f9f569
This PR does the following: - divides user msgs into 3 categories: plain, user instructions, and environment context - Centralizes adding user instructions and environment context to a degree - Improve the integration testing Building on top of #3123 Specifically this [comment](https://github.com/openai/codex/pull/3123#discussion_r2319885089). We need to send the user message while ignoring the User Instructions and Environment Context we attach.
118 lines
4.1 KiB
Rust
118 lines
4.1 KiB
Rust
use serde::Deserialize;
|
|
use serde::Serialize;
|
|
use strum_macros::Display as DeriveDisplay;
|
|
|
|
use crate::protocol::AskForApproval;
|
|
use crate::protocol::SandboxPolicy;
|
|
use crate::shell::Shell;
|
|
use codex_protocol::config_types::SandboxMode;
|
|
use codex_protocol::models::ContentItem;
|
|
use codex_protocol::models::ResponseItem;
|
|
use codex_protocol::protocol::ENVIRONMENT_CONTEXT_CLOSE_TAG;
|
|
use codex_protocol::protocol::ENVIRONMENT_CONTEXT_OPEN_TAG;
|
|
use std::path::PathBuf;
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, DeriveDisplay)]
|
|
#[serde(rename_all = "kebab-case")]
|
|
#[strum(serialize_all = "kebab-case")]
|
|
pub enum NetworkAccess {
|
|
Restricted,
|
|
Enabled,
|
|
}
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
#[serde(rename = "environment_context", rename_all = "snake_case")]
|
|
pub(crate) struct EnvironmentContext {
|
|
pub cwd: Option<PathBuf>,
|
|
pub approval_policy: Option<AskForApproval>,
|
|
pub sandbox_mode: Option<SandboxMode>,
|
|
pub network_access: Option<NetworkAccess>,
|
|
pub shell: Option<Shell>,
|
|
}
|
|
|
|
impl EnvironmentContext {
|
|
pub fn new(
|
|
cwd: Option<PathBuf>,
|
|
approval_policy: Option<AskForApproval>,
|
|
sandbox_policy: Option<SandboxPolicy>,
|
|
shell: Option<Shell>,
|
|
) -> Self {
|
|
Self {
|
|
cwd,
|
|
approval_policy,
|
|
sandbox_mode: match sandbox_policy {
|
|
Some(SandboxPolicy::DangerFullAccess) => Some(SandboxMode::DangerFullAccess),
|
|
Some(SandboxPolicy::ReadOnly) => Some(SandboxMode::ReadOnly),
|
|
Some(SandboxPolicy::WorkspaceWrite { .. }) => Some(SandboxMode::WorkspaceWrite),
|
|
None => None,
|
|
},
|
|
network_access: match sandbox_policy {
|
|
Some(SandboxPolicy::DangerFullAccess) => Some(NetworkAccess::Enabled),
|
|
Some(SandboxPolicy::ReadOnly) => Some(NetworkAccess::Restricted),
|
|
Some(SandboxPolicy::WorkspaceWrite { network_access, .. }) => {
|
|
if network_access {
|
|
Some(NetworkAccess::Enabled)
|
|
} else {
|
|
Some(NetworkAccess::Restricted)
|
|
}
|
|
}
|
|
None => None,
|
|
},
|
|
shell,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl EnvironmentContext {
|
|
/// Serializes the environment context to XML. Libraries like `quick-xml`
|
|
/// require custom macros to handle Enums with newtypes, so we just do it
|
|
/// manually, to keep things simple. Output looks like:
|
|
///
|
|
/// ```xml
|
|
/// <environment_context>
|
|
/// <cwd>...</cwd>
|
|
/// <approval_policy>...</approval_policy>
|
|
/// <sandbox_mode>...</sandbox_mode>
|
|
/// <network_access>...</network_access>
|
|
/// <shell>...</shell>
|
|
/// </environment_context>
|
|
/// ```
|
|
pub fn serialize_to_xml(self) -> String {
|
|
let mut lines = vec![ENVIRONMENT_CONTEXT_OPEN_TAG.to_string()];
|
|
if let Some(cwd) = self.cwd {
|
|
lines.push(format!(" <cwd>{}</cwd>", cwd.to_string_lossy()));
|
|
}
|
|
if let Some(approval_policy) = self.approval_policy {
|
|
lines.push(format!(
|
|
" <approval_policy>{approval_policy}</approval_policy>"
|
|
));
|
|
}
|
|
if let Some(sandbox_mode) = self.sandbox_mode {
|
|
lines.push(format!(" <sandbox_mode>{sandbox_mode}</sandbox_mode>"));
|
|
}
|
|
if let Some(network_access) = self.network_access {
|
|
lines.push(format!(
|
|
" <network_access>{network_access}</network_access>"
|
|
));
|
|
}
|
|
if let Some(shell) = self.shell
|
|
&& let Some(shell_name) = shell.name()
|
|
{
|
|
lines.push(format!(" <shell>{shell_name}</shell>"));
|
|
}
|
|
lines.push(ENVIRONMENT_CONTEXT_CLOSE_TAG.to_string());
|
|
lines.join("\n")
|
|
}
|
|
}
|
|
|
|
impl From<EnvironmentContext> for ResponseItem {
|
|
fn from(ec: EnvironmentContext) -> Self {
|
|
ResponseItem::Message {
|
|
id: None,
|
|
role: "user".to_string(),
|
|
content: vec![ContentItem::InputText {
|
|
text: ec.serialize_to_xml(),
|
|
}],
|
|
}
|
|
}
|
|
}
|