fix(fs_search): handle empty string file type from LLM tool calls (#2355)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: amitksingh1490

crates/forge_json_repair/src/schema_coercion.rs

@@ -45,6 +45,17 @@ fn coerce_value_with_schema_object(
             return coerce_value_with_schema(value, def_schema, root_schema);
         }
     }
+
+    // Coerce empty strings to null for nullable schemas.
+    // LLMs often send "" for optional parameters instead of omitting them or
+    // sending null. When the schema has "nullable": true (OpenAPI 3.0 style),
+    // an empty string should be treated as null.
+    if let Value::String(s) = &value
+        && s.is_empty()
+        && is_nullable(schema)
+    {
+        return Value::Null;
+    }
     // Handle anyOf/oneOf schemas by trying each sub-schema
     if let Some(subschemas) = &schema.subschemas {
         if let Some(any_of) = &subschemas.any_of {
@@ -157,6 +168,17 @@ fn coerce_by_instance_type(
     value
 }
 
+/// Checks if a schema is marked as nullable via the OpenAPI 3.0 "nullable"
+/// extension. This is set by schemars when `option_nullable = true` for
+/// `Option<T>` fields.
+fn is_nullable(schema: &SchemaObject) -> bool {
+    schema
+        .extensions
+        .get("nullable")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false)
+}
+
 fn type_matches(value: &Value, target_types: &[&InstanceType]) -> bool {
     target_types.iter().any(|t| match t {
         InstanceType::Null => value.is_null(),
@@ -1125,4 +1147,100 @@ mod tests {
 
         assert_eq!(actual, expected);
     }
+
+    #[test]
+    fn test_coerce_empty_string_to_null_for_nullable_field() {
+        // Simulates LLM sending "" for a nullable string field (e.g., file_type in
+        // fs_search). The schema uses "nullable: true" (OpenAPI 3.0 style).
+        #[derive(JsonSchema)]
+        #[allow(dead_code)]
+        struct NullableStringData {
+            required_field: String,
+            #[schemars(default)]
+            optional_field: Option<String>,
+        }
+
+        // Generate schema with option_nullable=true (matching project settings)
+        let r#gen = schemars::r#gen::SchemaSettings::default()
+            .with(|s| {
+                s.option_nullable = true;
+                s.option_add_null_type = false;
+            })
+            .into_generator();
+        let schema = r#gen.into_root_schema_for::<NullableStringData>();
+
+        let fixture = json!({
+            "required_field": "value",
+            "optional_field": ""
+        });
+        let actual = coerce_to_schema(fixture, &schema);
+        let expected = json!({
+            "required_field": "value",
+            "optional_field": null
+        });
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_preserve_nonempty_string_for_nullable_field() {
+        // Non-empty strings should be preserved even for nullable fields
+        #[derive(JsonSchema)]
+        #[allow(dead_code)]
+        struct NullableStringData {
+            optional_field: Option<String>,
+        }
+
+        let r#gen = schemars::r#gen::SchemaSettings::default()
+            .with(|s| {
+                s.option_nullable = true;
+                s.option_add_null_type = false;
+            })
+            .into_generator();
+        let schema = r#gen.into_root_schema_for::<NullableStringData>();
+
+        let fixture = json!({"optional_field": "rust"});
+        let actual = coerce_to_schema(fixture, &schema);
+        let expected = json!({"optional_field": "rust"});
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_preserve_empty_string_for_required_field() {
+        // Empty strings should NOT be converted to null for non-nullable fields
+        #[derive(JsonSchema)]
+        #[allow(dead_code)]
+        struct RequiredStringData {
+            name: String,
+        }
+
+        let schema = schema_for!(RequiredStringData);
+
+        let fixture = json!({"name": ""});
+        let actual = coerce_to_schema(fixture, &schema);
+        let expected = json!({"name": ""});
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_coerce_empty_string_to_null_for_nullable_integer() {
+        // Empty string for a nullable integer should become null
+        #[derive(JsonSchema)]
+        #[allow(dead_code)]
+        struct NullableIntData {
+            count: Option<u32>,
+        }
+
+        let r#gen = schemars::r#gen::SchemaSettings::default()
+            .with(|s| {
+                s.option_nullable = true;
+                s.option_add_null_type = false;
+            })
+            .into_generator();
+        let schema = r#gen.into_root_schema_for::<NullableIntData>();
+
+        let fixture = json!({"count": ""});
+        let actual = coerce_to_schema(fixture, &schema);
+        let expected = json!({"count": null});
+        assert_eq!(actual, expected);
+    }
 }

crates/forge_services/src/tool_services/fs_search.rs

@@ -101,21 +101,24 @@ impl<W: WalkerInfra + FileReaderInfra + FileInfoInfra> ForgeFsSearch<W> {
         params: &FSSearch,
     ) -> anyhow::Result<Vec<PathBuf>> {
         // Build type matcher once if file_type is specified (for efficiency)
-        let types_matcher = if let Some(file_type) = &params.file_type {
-            use ignore::types::TypesBuilder;
-
-            let mut builder = TypesBuilder::new();
-            builder.add_defaults();
-            builder.select(file_type);
-
-            Some(
-                builder
-                    .build()
-                    .with_context(|| format!("Failed to build type matcher for: {file_type}"))?,
-            )
-        } else {
-            None
-        };
+        // Filter out empty strings that may arrive from LLM tool calls with nullable
+        // parameters
+        let types_matcher =
+            if let Some(file_type) = params.file_type.as_deref().filter(|s| !s.is_empty()) {
+                use ignore::types::TypesBuilder;
+
+                let mut builder = TypesBuilder::new();
+                builder.add_defaults();
+                builder.select(file_type);
+
+                Some(
+                    builder.build().with_context(|| {
+                        format!("Failed to build type matcher for: {file_type}")
+                    })?,
+                )
+            } else {
+                None
+            };
 
         let paths = if self.infra.is_file(search_path).await? {
             vec![search_path.to_path_buf()]
@@ -682,6 +685,29 @@ mod test {
         );
     }
 
+    #[tokio::test]
+    async fn test_empty_file_type_treated_as_none() {
+        let fixture = create_test_directory().await.unwrap();
+        let params = FSSearch {
+            pattern: "test".to_string(),
+            path: Some(fixture.path().to_string_lossy().to_string()),
+            file_type: Some("".to_string()),
+            output_mode: Some(OutputMode::FilesWithMatches),
+            ..Default::default()
+        };
+
+        // Should not error - empty file_type should be treated as None
+        let actual = ForgeFsSearch::new(Arc::new(MockInfra::default()))
+            .search(params)
+            .await
+            .unwrap();
+
+        assert!(actual.is_some());
+        let result = actual.unwrap();
+        // Should match files across all types (not filtered)
+        assert!(result.matches.len() >= 3);
+    }
+
     #[tokio::test]
     async fn test_glob_filter() {
         let fixture = create_test_directory().await.unwrap();