Route view_image through selected environments

codex-rs/core/src/tools/handlers/view_image.rs

@@ -17,6 +17,7 @@ use crate::tools::context::ToolInvocation;
 use crate::tools::context::ToolOutput;
 use crate::tools::context::ToolPayload;
 use crate::tools::handlers::parse_arguments;
+use crate::tools::handlers::resolve_tool_environment;
 use crate::tools::handlers::view_image_spec::ViewImageToolOptions;
 use crate::tools::handlers::view_image_spec::create_view_image_tool;
 use crate::tools::registry::ToolHandler;
@@ -33,6 +34,7 @@ impl Default for ViewImageHandler {
         Self {
             options: ViewImageToolOptions {
                 can_request_original_image_detail: false,
+                include_environment_id: false,
             },
         }
     }
@@ -50,6 +52,8 @@ const VIEW_IMAGE_UNSUPPORTED_MESSAGE: &str =
 #[derive(Deserialize)]
 struct ViewImageArgs {
     path: String,
+    #[serde(default)]
+    environment_id: Option<String>,
     detail: Option<String>,
 }
 
@@ -106,12 +110,16 @@ impl ToolHandler for ViewImageHandler {
             }
         };
 
-        let args: ViewImageArgs = parse_arguments(&arguments)?;
+        let ViewImageArgs {
+            path,
+            environment_id,
+            detail,
+        } = parse_arguments(&arguments)?;
         // `view_image` accepts only its documented detail values: omit
         // `detail` for the default path or set it to `original`.
         // Other string values remain invalid rather than being silently
         // reinterpreted.
-        let detail = match args.detail.as_deref() {
+        let detail = match detail.as_deref() {
             None => None,
             Some("original") => Some(ViewImageDetail::Original),
             Some(detail) => {
@@ -121,20 +129,24 @@ impl ToolHandler for ViewImageHandler {
             }
         };
 
-        let abs_path = turn.resolve_path(Some(args.path));
-        let Some(environment) = turn.environments.primary() else {
+        let Some(turn_environment) =
+            resolve_tool_environment(turn.as_ref(), environment_id.as_deref())?
+        else {
             return Err(FunctionCallError::RespondToModel(
                 "view_image is unavailable in this session".to_string(),
             ));
         };
-        let sandbox = environment
-            .environment
-            .is_remote()
-            .then(|| turn.file_system_sandbox_context(/*additional_permissions*/ None));
-
-        let metadata = environment
-            .environment
-            .get_filesystem()
+        let cwd = turn_environment.cwd.clone();
+        let abs_path = cwd.join(path);
+        let sandbox = turn_environment.environment.is_remote().then(|| {
+            let mut sandbox =
+                turn.file_system_sandbox_context(/*additional_permissions*/ None);
+            sandbox.cwd = Some(cwd.clone());
+            sandbox
+        });
+        let fs = turn_environment.environment.get_filesystem();
+
+        let metadata = fs
             .get_metadata(&abs_path, sandbox.as_ref())
             .await
             .map_err(|error| {
@@ -150,9 +162,7 @@ impl ToolHandler for ViewImageHandler {
                 abs_path.display()
             )));
         }
-        let file_bytes = environment
-            .environment
-            .get_filesystem()
+        let file_bytes = fs
             .read_file(&abs_path, sandbox.as_ref())
             .await
             .map_err(|error| {

codex-rs/core/src/tools/handlers/view_image_spec.rs

@@ -9,6 +9,7 @@ use std::collections::BTreeMap;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ViewImageToolOptions {
     pub can_request_original_image_detail: bool,
+    pub include_environment_id: bool,
 }
 
 pub fn create_view_image_tool(options: ViewImageToolOptions) -> ToolSpec {
@@ -24,6 +25,15 @@ pub fn create_view_image_tool(options: ViewImageToolOptions) -> ToolSpec {
             )),
         );
     }
+    if options.include_environment_id {
+        properties.insert(
+            "environment_id".to_string(),
+            JsonSchema::string(Some(
+                "Optional selected environment id to target. Omit this to use the primary environment."
+                    .to_string(),
+            )),
+        );
+    }
 
     ToolSpec::Function(ResponsesApiTool {
         name: VIEW_IMAGE_TOOL_NAME.to_string(),

codex-rs/core/src/tools/spec_plan.rs

@@ -289,8 +289,11 @@ pub fn build_tool_registry_builder(
     }
 
     if config.environment_mode.has_environment() {
+        let include_environment_id =
+            matches!(config.environment_mode, ToolEnvironmentMode::Multiple);
         builder.register_handler(Arc::new(ViewImageHandler::new(ViewImageToolOptions {
             can_request_original_image_detail: config.can_request_original_image_detail,
+            include_environment_id,
         })));
     }
 

codex-rs/core/src/tools/spec_plan_tests.rs

@@ -129,6 +129,7 @@ fn test_full_toolset_specs_for_gpt5_codex_unified_exec_web_search() {
         create_image_generation_tool("png"),
         create_view_image_tool(ViewImageToolOptions {
             can_request_original_image_detail: config.can_request_original_image_detail,
+            include_environment_id: false,
         }),
     ] {
         expected.insert(spec.name().to_string(), spec);
@@ -628,6 +629,48 @@ fn disabled_environment_omits_environment_backed_tools() {
     assert_lacks_tool_name(&tools, VIEW_IMAGE_TOOL_NAME);
 }
 
+#[test]
+fn view_image_spec_includes_environment_id_only_for_multiple_selected_environments() {
+    let model_info = model_info();
+    let available_models = Vec::new();
+    let tools_config = ToolsConfig::new(&ToolsConfigParams {
+        model_info: &model_info,
+        available_models: &available_models,
+        features: &Features::with_defaults(),
+        image_generation_tool_auth_allowed: true,
+        web_search_mode: Some(WebSearchMode::Cached),
+        session_source: SessionSource::Cli,
+        permission_profile: &PermissionProfile::Disabled,
+        windows_sandbox_level: WindowsSandboxLevel::Disabled,
+    });
+
+    let (single_environment_tools, _) = build_specs(
+        &tools_config,
+        /*mcp_tools*/ None,
+        /*deferred_mcp_tools*/ None,
+        &[],
+    );
+    assert_process_tool_environment_id(
+        &single_environment_tools,
+        VIEW_IMAGE_TOOL_NAME,
+        /*expected_present*/ false,
+    );
+
+    let multi_environment_config =
+        tools_config.with_environment_mode(ToolEnvironmentMode::Multiple);
+    let (multi_environment_tools, _) = build_specs(
+        &multi_environment_config,
+        /*mcp_tools*/ None,
+        /*deferred_mcp_tools*/ None,
+        &[],
+    );
+    assert_process_tool_environment_id(
+        &multi_environment_tools,
+        VIEW_IMAGE_TOOL_NAME,
+        /*expected_present*/ true,
+    );
+}
+
 #[test]
 fn test_build_specs_agent_job_worker_tools_enabled() {
     let model_info = model_info();