Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@plane/api/work_item_properties/base.py`:
- Around line 108-110: The project-level API paths in
plane/api/work_item_properties/base.py are missing trailing slashes; update the
formatted endpoint strings (e.g.,
f"{workspace_slug}/projects/{project_id}/work-item-properties", and the other
similar occurrences referenced in the comment) to include a trailing "/" so they
follow the convention ({base_path}/api/v1{resource_base_path}/{endpoint}/).
Locate each _get/_post/_put call that uses those f-strings (the occurrences
around the provided diffs) and append "/" to the end of the path string,
ensuring all new project-level endpoints end with a trailing slash.
- Line 191: The current return uses response.get("properties", []) which can
yield non-list values; replace that single return with a guarded/coercing block:
fetch props = response.get("properties", None), if isinstance(props, str) return
[props], if isinstance(props, list) return [p for p in props if isinstance(p,
str)] (or map to str if you prefer), otherwise return [] (or raise TypeError if
stricter behavior is desired) so callers always receive list[str]; update the
code around the return response.get("properties", []) to implement this
validation/coercion.

In `@plane/api/work_items/base.py`:
- Line 193: The endpoint string f"{workspace_slug}/work-items" must include a
trailing slash per API conventions; update the call that builds the URL (the
field using f"{workspace_slug}/work-items", params=query_params) to use
f"{workspace_slug}/work-items/" so the final request path ends with a "/" and
matches the {base_path}/api/v1{resource_base_path}/{endpoint}/ pattern.

In `@plane/api/workspace_work_item_types/properties.py`:
- Around line 25-29: The code currently does return list(response) immediately
after calling
self._get(f"{workspace_slug}/work-item-types/{type_id}/properties/"), which will
silently iterate dict keys if the API changes; update this method to validate
the response shape before converting: after the self._get(...) call
assert/inspect that response is a list (e.g., isinstance(response, list)), and
if not, raise a clear error (or handle the expected envelope like
response.get("items") if your API uses that) including the actual response
contents for debugging; ensure the error mentions the workspace_slug and type_id
so callers can trace the failing request.

In `@tests/unit/test_work_item_properties.py`:
- Around line 711-716: Replace the broad "except Exception: pass" in the
teardown calls to client.work_item_properties.delete_project with a targeted
handler: catch the specific client/API exception type thrown by the SDK (e.g.,
ApiError/HTTPError or the library's specific exception) and either log the error
or re-raise/assert so cleanup failures are visible; apply the same change to
both occurrences that call client.work_item_properties.delete_project (the
blocks using workspace_slug, project.id, created.id). Ensure you import the
specific exception class and include the caught exception in the log message
instead of silencing it.
- Line 751: The create_project call can raise an HTTP 400 in environments that
block project-level property creation; wrap the line that calls
client.work_item_properties.create_project(workspace_slug, project.id,
prop_data) in a try/except that catches the HTTPError (or the client-specific
exception) and if the exception's response/status_code is 400 invoke pytest.skip
with the same message used in the prior attach/detach test so the test is
skipped consistently; keep the original variable name prop and only skip on that
specific 400 condition.

In `@tests/unit/test_workspace_work_item_properties.py`:
- Around line 173-179: The teardown is catching all exceptions with "except
Exception" which hides real failures; change the try/except around
client.workspace_work_item_properties.delete(workspace_slug, prop.id) to either
remove the broad except so exceptions propagate and fail the test, or catch a
concrete SDK error type (e.g., ApiError/SDKError) imported from the SDK and
log/warn only that specific exception; update the except clause to reference the
concrete exception class and remove the generic "Exception" handler.

In `@tests/unit/test_workspace_work_item_types.py`:
- Around line 57-58: The test uses wit.id (from types[0]) without ensuring it's
not None; add a guard to assert or raise if wit.id is None before calling
client.workspace_work_item_types.retrieve(workspace_slug, wit.id). Locate the
variables wit and types in this test, verify wit is not None, then do an
explicit assert wit.id is not None (or a conditional that fails the test with a
clear message) so the subsequent retrieve call always receives a non-optional
id.
- Around line 44-47: The teardown currently swallows all errors in the cleanup:
replace the broad "except Exception: pass" around
client.workspace_work_item_types.delete(workspace_slug, created.id) with a
targeted handling strategy—either let errors propagate (remove the try/except)
so test failures surface, or catch the client-specific exception (e.g.,
ApiException/HTTPError) and log it or re-raise after logging; alternatively move
deletion into a pytest finalizer/fixture to ensure deterministic cleanup and
visible failures. Ensure you reference client.workspace_work_item_types.delete,
workspace_slug, and created.id when updating the code.

---

Nitpick comments:
In `@tests/unit/test_work_items.py`:
- Line 95: Remove the redundant local import of WorkItemQueryParams in
tests/unit/test_work_items.py (the extra "from plane.models.query_params import
WorkItemQueryParams" shown in the diff) since WorkItemQueryParams is already
imported at module level; simply delete this duplicate import line and run the
tests to confirm there are no other missing imports or name collisions.