fix rebase error

This commit is contained in:
Liang-Ting Jiang
2026-04-22 01:23:48 -07:00
parent 1ce4c6064c
commit 333251b16d
8 changed files with 69 additions and 164 deletions
+59 -24
View File
@@ -118,6 +118,22 @@ fn openai_file_api_base_url(base_url: &str) -> String {
base_url.trim_end_matches('/').to_string()
}
fn local_dev_openai_file_api_base_url(base_url: &str) -> Option<String> {
let mut url = Url::parse(base_url).ok()?;
match url.host_str()? {
"localhost" | "127.0.0.1" | "::1" => {}
_ => return None,
}
if url.port_or_known_default() == Some(8000) {
return None;
}
url.set_port(Some(8000)).ok()?;
url.set_path("/api");
url.set_query(None);
url.set_fragment(None);
Some(url.to_string().trim_end_matches('/').to_string())
}
pub async fn download_openai_file(
base_url: &str,
auth: &impl AuthProvider,
@@ -192,8 +208,6 @@ pub async fn upload_local_file(
.and_then(|value| value.to_str())
.unwrap_or("file")
.to_string();
let api_base_url = openai_file_api_base_url(base_url);
let create_url = format!("{api_base_url}/files");
let mut create_request = serde_json::json!({
"file_name": file_name,
"file_size": metadata.len(),
@@ -202,28 +216,20 @@ pub async fn upload_local_file(
if options.store_in_library {
create_request["store_in_library"] = serde_json::json!(true);
}
let create_response = authorized_request(auth, reqwest::Method::POST, &create_url)
.json(&create_request)
.send()
.await
.map_err(|source| OpenAiFileError::Request {
url: create_url.clone(),
source,
})?;
let create_status = create_response.status();
let create_body = create_response.text().await.unwrap_or_default();
if !create_status.is_success() {
return Err(OpenAiFileError::UnexpectedStatus {
url: create_url,
status: create_status,
body: create_body,
});
}
let create_payload: CreateFileResponse =
serde_json::from_str(&create_body).map_err(|source| OpenAiFileError::Decode {
url: create_url.clone(),
source,
})?;
let mut api_base_url = openai_file_api_base_url(base_url);
let create_payload = match create_file(auth, &api_base_url, &create_request).await {
Ok(payload) => payload,
Err(OpenAiFileError::UnexpectedStatus { status, .. })
if status == StatusCode::NOT_FOUND =>
{
let Some(local_dev_api_base_url) = local_dev_openai_file_api_base_url(base_url) else {
return create_file(auth, &api_base_url, &create_request).await;
};
api_base_url = local_dev_api_base_url;
create_file(auth, &api_base_url, &create_request).await?
}
Err(error) => return Err(error),
};
let upload_file = File::open(path)
.await
@@ -328,6 +334,35 @@ pub async fn upload_local_file(
}
}
async fn create_file(
auth: &dyn AuthProvider,
api_base_url: &str,
create_request: &serde_json::Value,
) -> Result<CreateFileResponse, OpenAiFileError> {
let create_url = format!("{api_base_url}/files");
let create_response = authorized_request(auth, reqwest::Method::POST, &create_url)
.json(create_request)
.send()
.await
.map_err(|source| OpenAiFileError::Request {
url: create_url.clone(),
source,
})?;
let create_status = create_response.status();
let create_body = create_response.text().await.unwrap_or_default();
if !create_status.is_success() {
return Err(OpenAiFileError::UnexpectedStatus {
url: create_url,
status: create_status,
body: create_body,
});
}
serde_json::from_str(&create_body).map_err(|source| OpenAiFileError::Decode {
url: create_url,
source,
})
}
fn authorized_request(
auth: &dyn AuthProvider,
method: reqwest::Method,
-2
View File
@@ -272,8 +272,6 @@ pub struct ConfigToml {
/// Base URL for requests to ChatGPT (as opposed to the OpenAI API).
pub chatgpt_base_url: Option<String>,
/// Optional override for the OpenAI file upload/download API base.
pub openai_file_api_base_url: Option<String>,
/// Base URL override for the built-in `openai` model provider.
pub openai_base_url: Option<String>,
-1
View File
@@ -38,7 +38,6 @@ pub struct ConfigProfile {
pub model_catalog_json: Option<AbsolutePathBuf>,
pub personality: Option<Personality>,
pub chatgpt_base_url: Option<String>,
pub openai_file_api_base_url: Option<String>,
/// Optional path to a file containing model instructions.
pub model_instructions_file: Option<AbsolutePathBuf>,
pub js_repl_node_path: Option<AbsolutePathBuf>,
+3 -10
View File
@@ -29,12 +29,8 @@ struct CodexAppsFileUri {
file_name: Option<String>,
}
fn codex_apps_download_base_url<'a>(turn_context: &'a TurnContext, download_url: &str) -> &'a str {
if download_url.starts_with("/api/codex/") {
turn_context.config.chatgpt_base_url.as_str()
} else {
turn_context.config.openai_file_api_base_url()
}
fn codex_apps_download_base_url(turn_context: &TurnContext) -> &str {
turn_context.config.chatgpt_base_url.as_str()
}
pub(crate) async fn maybe_materialize_codex_apps_file_download_result(
@@ -83,8 +79,7 @@ async fn maybe_materialize_codex_apps_file_download_result_with_auth(
let Some(payload) = extract_codex_apps_file_download_payload(&result) else {
return result;
};
let download_base_url =
codex_apps_download_base_url(turn_context, &payload.file_uri.download_url);
let download_base_url = codex_apps_download_base_url(turn_context);
if result.structured_content.is_none()
&& let Ok(structured_content) = serde_json::to_value(&payload)
{
@@ -350,7 +345,6 @@ mod tests {
#[tokio::test]
async fn codex_apps_file_download_materialization_uses_chatgpt_base_for_relative_codex_urls() {
let chatgpt_server = MockServer::start().await;
let file_api_server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/api/codex/files/file_123/content"))
.and(header("authorization", "Bearer Access Token"))
@@ -366,7 +360,6 @@ mod tests {
let (_, mut turn_context) = make_session_and_context().await;
let mut config = (*turn_context.config).clone();
config.chatgpt_base_url = chatgpt_server.uri();
config.openai_file_api_base_url = Some(format!("{}/backend-api", file_api_server.uri()));
turn_context.config = Arc::new(config);
let original = CallToolResult {
content: vec![],
-1
View File
@@ -5005,7 +5005,6 @@ async fn test_precedence_fixture_with_o3_profile() -> std::io::Result<()> {
model_verbosity: None,
personality: Some(Personality::Pragmatic),
chatgpt_base_url: "https://chatgpt.com/backend-api/".to_string(),
openai_file_api_base_url: None,
realtime_audio: RealtimeAudioConfig::default(),
experimental_realtime_start_instructions: None,
experimental_realtime_ws_base_url: None,
-11
View File
@@ -512,8 +512,6 @@ pub struct Config {
/// Base URL for requests to ChatGPT (as opposed to the OpenAI API).
pub chatgpt_base_url: String,
/// Optional override for the OpenAI file upload/download API base.
pub openai_file_api_base_url: Option<String>,
/// Machine-local realtime audio device preferences used by realtime voice.
pub realtime_audio: RealtimeAudioConfig,
@@ -800,12 +798,6 @@ impl ConfigBuilder {
}
impl Config {
pub fn openai_file_api_base_url(&self) -> &str {
self.openai_file_api_base_url
.as_deref()
.unwrap_or(self.chatgpt_base_url.as_str())
}
pub fn to_models_manager_config(&self) -> ModelsManagerConfig {
ModelsManagerConfig {
model_context_window: self.model_context_window,
@@ -2317,9 +2309,6 @@ impl Config {
.chatgpt_base_url
.or(cfg.chatgpt_base_url)
.unwrap_or("https://chatgpt.com/backend-api/".to_string()),
openai_file_api_base_url: config_profile
.openai_file_api_base_url
.or(cfg.openai_file_api_base_url),
realtime_audio: cfg
.audio
.map_or_else(RealtimeAudioConfig::default, |audio| RealtimeAudioConfig {
-102
View File
@@ -12,11 +12,8 @@
use crate::session::session::Session;
use crate::session::turn_context::TurnContext;
<<<<<<< HEAD
=======
use codex_api::AuthProvider;
use codex_api::OpenAiFileUploadOptions;
>>>>>>> 39d265536 (Add metadata-driven OpenAI file support for builtin codex_apps tools)
use codex_api::upload_local_file;
use codex_login::CodexAuth;
use codex_model_provider::BearerAuthProvider;
@@ -46,11 +43,6 @@ pub(crate) async fn rewrite_mcp_tool_arguments_for_openai_files(
let Some(value) = arguments.get(field_name) else {
continue;
};
<<<<<<< HEAD
let Some(uploaded_value) =
rewrite_argument_value_for_openai_files(turn_context, auth.as_ref(), field_name, value)
.await?
=======
let Some(uploaded_value) = rewrite_argument_value_for_openai_files(
sess,
turn_context,
@@ -60,7 +52,6 @@ pub(crate) async fn rewrite_mcp_tool_arguments_for_openai_files(
upload_options,
)
.await?
>>>>>>> 39d265536 (Add metadata-driven OpenAI file support for builtin codex_apps tools)
else {
continue;
};
@@ -141,16 +132,11 @@ async fn build_uploaded_local_argument_value(
};
let default_upload_options = OpenAiFileUploadOptions::default();
let uploaded = upload_local_file(
<<<<<<< HEAD
turn_context.config.chatgpt_base_url.trim_end_matches('/'),
&upload_auth,
=======
turn_context
.config
.openai_file_api_base_url()
.trim_end_matches('/'),
upload_auth.as_ref(),
>>>>>>> e66c01c9f (clean)
&resolved_path,
upload_options.unwrap_or(&default_upload_options),
)
@@ -519,92 +505,4 @@ mod tests {
assert!(error.contains("failed to upload"));
assert!(error.contains("file"));
}
<<<<<<< HEAD
=======
#[tokio::test]
async fn build_uploaded_local_argument_value_uses_agent_assertion_for_cached_task() {
use wiremock::Mock;
use wiremock::MockServer;
use wiremock::ResponseTemplate;
use wiremock::matchers::body_json;
use wiremock::matchers::header_regex;
use wiremock::matchers::method;
use wiremock::matchers::path;
let server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/backend-api/files"))
.and(header_regex("authorization", r"^AgentAssertion .+"))
.and(body_json(serde_json::json!({
"file_name": "file_report.csv",
"file_size": 5,
"use_case": "codex",
})))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"file_id": "file_123",
"upload_url": format!("{}/upload/file_123", server.uri()),
})))
.expect(1)
.mount(&server)
.await;
Mock::given(method("PUT"))
.and(path("/upload/file_123"))
.respond_with(ResponseTemplate::new(200))
.expect(1)
.mount(&server)
.await;
Mock::given(method("POST"))
.and(path("/backend-api/files/file_123/uploaded"))
.and(header_regex("authorization", r"^AgentAssertion .+"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"status": "success",
"download_url": format!("{}/download/file_123", server.uri()),
"file_name": "file_report.csv",
"mime_type": "text/csv",
"file_size_bytes": 5,
})))
.expect(1)
.mount(&server)
.await;
let (mut session, mut turn_context) = make_session_and_context().await;
let auth = CodexAuth::create_dummy_chatgpt_auth_for_testing();
let dir = tempdir().expect("temp dir");
let local_path = dir.path().join("file_report.csv");
tokio::fs::write(&local_path, b"hello")
.await
.expect("write local file");
turn_context.cwd = AbsolutePathBuf::try_from(dir.path()).expect("absolute path");
let mut config = (*turn_context.config).clone();
config.chatgpt_base_url = format!("{}/backend-api", server.uri());
turn_context.config = Arc::new(config);
install_cached_agent_task_auth(&mut session, &mut turn_context, server.uri()).await;
let rewritten = build_uploaded_local_argument_value(
&session,
&turn_context,
Some(&auth),
"file",
/*index*/ None,
"file_report.csv",
None,
)
.await
.expect("rewrite should upload the local file");
assert_eq!(
rewritten,
serde_json::json!({
"download_url": format!("{}/download/file_123", server.uri()),
"file_id": "file_123",
"mime_type": "text/csv",
"file_name": "file_report.csv",
"uri": "sediment://file_123",
"file_size_bytes": 5,
})
);
}
>>>>>>> 39d265536 (Add metadata-driven OpenAI file support for builtin codex_apps tools)
}
+7 -13
View File
@@ -39,8 +39,6 @@ fn configure_apps(config: &mut Config, chatgpt_base_url: &str) {
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn codex_apps_file_params_upload_local_paths_before_mcp_tool_call() -> Result<()> {
let server = start_mock_server().await;
let upload_server = start_mock_server().await;
let upload_server_uri = upload_server.uri();
let apps_server = AppsTestServer::mount(&server).await?;
Mock::given(method("POST"))
@@ -53,33 +51,32 @@ async fn codex_apps_file_params_upload_local_paths_before_mcp_tool_call() -> Res
})))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"file_id": "file_123",
"upload_url": format!("{}/upload/file_123", upload_server_uri),
"upload_url": format!("{}/upload/file_123", server.uri()),
})))
.expect(1)
.mount(&upload_server)
.mount(&server)
.await;
Mock::given(method("PUT"))
.and(path("/upload/file_123"))
.and(header("content-length", "11"))
.respond_with(ResponseTemplate::new(200))
.expect(1)
.mount(&upload_server)
.mount(&server)
.await;
Mock::given(method("POST"))
.and(path("/api/files/file_123/uploaded"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"status": "success",
"download_url": format!("{}/download/file_123", upload_server_uri),
"download_url": format!("{}/download/file_123", server.uri()),
"file_name": "report.txt",
"mime_type": "text/plain",
"file_size_bytes": 11,
})))
.expect(1)
.mount(&upload_server)
.mount(&server)
.await;
let call_id = "extract-call-1";
let upload_server_api_base = format!("{}/api", upload_server_uri);
let mock = mount_sse_sequence(
&server,
vec![
@@ -104,10 +101,7 @@ async fn codex_apps_file_params_upload_local_paths_before_mcp_tool_call() -> Res
let mut builder = test_codex()
.with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
.with_config(move |config| {
configure_apps(config, apps_server.chatgpt_base_url.as_str());
config.openai_file_api_base_url = Some(upload_server_api_base.clone());
});
.with_config(move |config| configure_apps(config, apps_server.chatgpt_base_url.as_str()));
let test = builder.build(&server).await?;
tokio::fs::write(test.cwd.path().join("report.txt"), b"hello world").await?;
@@ -153,7 +147,7 @@ async fn codex_apps_file_params_upload_local_paths_before_mcp_tool_call() -> Res
assert_eq!(
apps_tool_call.pointer("/params/arguments/file"),
Some(&json!({
"download_url": format!("{}/download/file_123", upload_server_uri),
"download_url": format!("{}/download/file_123", server.uri()),
"file_id": "file_123",
"mime_type": "text/plain",
"file_name": "report.txt",