fix(models): address review feedback on typed Bubble accessors

Author: clean6378-max-it

api/composers.py

@@ -98,12 +98,13 @@ def list_composers() -> tuple[Response, int] | Response:
                         # load-bearing, not just a filter (Brad's review): the
                         # sort key and the JSON's composerId both read off the
                         # validated values, not the raw dict.
-                        c["composerId"] = local.composer_id
-                        c["lastUpdatedAt"] = local.last_updated_at
-                        c["conversation"] = c.get("conversation") or []
-                        c["workspaceId"] = name
-                        c["workspaceFolder"] = workspace_folder
-                        composers.append((local, c))
+                        payload = local.cursor_storage_payload()
+                        payload["composerId"] = local.composer_id
+                        payload["lastUpdatedAt"] = local.last_updated_at
+                        payload["conversation"] = payload.get("conversation") or []
+                        payload["workspaceId"] = name
+                        payload["workspaceFolder"] = workspace_folder
+                        composers.append((local, payload))
             except SchemaError as e:
                 _logger.warning(
                     "Schema drift in %s: %s (%s)",

models/conversation.py

@@ -27,6 +27,50 @@
 _logger = logging.getLogger(__name__)
 
 
+def _filter_str_list_elements(
+    value: list[Any],
+    *,
+    model: str,
+    record_id: str,
+    field: str,
+) -> list[str]:
+    filtered: list[str] = []
+    for item in value:
+        if isinstance(item, str):
+            filtered.append(item)
+        else:
+            _logger.warning(
+                "Schema drift in %s %s: invalid %s element (expected str, got %s)",
+                model,
+                record_id,
+                field,
+                type(item).__name__,
+            )
+    return filtered
+
+
+def _filter_dict_list_elements(
+    value: list[Any],
+    *,
+    model: str,
+    record_id: str,
+    field: str,
+) -> list[FileUriDict]:
+    filtered: list[FileUriDict] = []
+    for item in value:
+        if isinstance(item, dict):
+            filtered.append(cast(FileUriDict, item))
+        else:
+            _logger.warning(
+                "Schema drift in %s %s: invalid %s element (expected dict, got %s)",
+                model,
+                record_id,
+                field,
+                type(item).__name__,
+            )
+    return filtered
+
+
 @dataclass(frozen=True)
 class Composer:
     """Cursor conversation row from globalStorage cursorDiskKV; requires fullConversationHeadersOnly + createdAt."""
@@ -287,7 +331,12 @@ def relevant_files(self) -> list[str]:
                 type(value).__name__,
             )
             return []
-        return cast(list[str], value)
+        return _filter_str_list_elements(
+            value,
+            model="Bubble",
+            record_id=self.bubble_id,
+            field="relevantFiles",
+        )
 
     @property
     def attached_file_code_chunks_uris(self) -> list[FileUriDict]:
@@ -301,7 +350,12 @@ def attached_file_code_chunks_uris(self) -> list[FileUriDict]:
                 type(value).__name__,
             )
             return []
-        return cast(list[FileUriDict], value)
+        return _filter_dict_list_elements(
+            value,
+            model="Bubble",
+            record_id=self.bubble_id,
+            field="attachedFileCodeChunksUris",
+        )
 
     @property
     def context(self) -> BubbleContextDict:

models/conversation_types.py

@@ -12,7 +12,12 @@ class FileUriDict(TypedDict, total=False):
 
 
 class BubbleMetadataDict(TypedDict, total=False):
-    """Storage ``metadata`` blob on a bubble row."""
+    """Storage ``metadata`` blob on a bubble row (subset we read here).
+
+    Rich display metadata (tool calls, token counts, thinking) is assembled in
+    :func:`utils.display_bubble.build_storage_bubble_metadata` from typed
+    bubble fields, not from this dict alone.
+    """
 
     modelName: str
 

tests/test_blob_parsing_fuzz.py

@@ -184,7 +184,8 @@ def _assemble_workspace_bubble(bubble_id: object, value: object) -> dict | None:
     except (json.JSONDecodeError, TypeError, ValueError):
         return None
     try:
-        return Bubble.from_dict(parsed, bubble_id=bubble_id)._raw  # type: ignore[arg-type]
+        bubble = Bubble.from_dict(parsed, bubble_id=bubble_id)
+        return bubble.cursor_storage_payload()  # type: ignore[arg-type]
     except SchemaError:
         return None
 
@@ -205,6 +206,7 @@ def test_never_raises_unhandled(self, raw: dict, bubble_id: str) -> None:
         if bubble is None:
             return
         self.assertEqual(bubble.bubble_id, bubble_id)
+        # from_dict stores the parsed dict by reference (no copy on construction).
         self.assertIs(bubble._raw, raw)
 
     @given(raw=_BUBBLE_RAW_ANY, bubble_id=_BUBBLE_ID_ANY)

tests/test_raw_accessors.py

@@ -46,6 +46,34 @@ def test_bubble_relevant_files_empty_when_key_missing(self) -> None:
         with self.assertNoLogs("models.conversation", level="WARNING"):
             self.assertEqual(bubble.relevant_files, [])
 
+    def test_bubble_relevant_files_skips_non_str_elements(self) -> None:
+        bubble = Bubble.from_dict(
+            {"relevantFiles": ["/good.py", 123, None, "/also.py"]},
+            bubble_id="b-rel",
+        )
+        with self.assertLogs("models.conversation", level="WARNING") as logs:
+            self.assertEqual(bubble.relevant_files, ["/good.py", "/also.py"])
+        self.assertTrue(any("relevantFiles" in m for m in logs.output), logs.output)
+
+    def test_bubble_attached_file_uris_skips_non_dict_elements(self) -> None:
+        bubble = Bubble.from_dict(
+            {
+                "attachedFileCodeChunksUris": [
+                    {"path": "/a.py"},
+                    "bad",
+                    {"path": "/b.py"},
+                ]
+            },
+            bubble_id="b-uri",
+        )
+        with self.assertLogs("models.conversation", level="WARNING") as logs:
+            uris = bubble.attached_file_code_chunks_uris
+        self.assertEqual(uris, [{"path": "/a.py"}, {"path": "/b.py"}])
+        self.assertTrue(
+            any("attachedFileCodeChunksUris" in m for m in logs.output),
+            logs.output,
+        )
+
     def test_project_layouts_silent_when_key_missing(self) -> None:
         with self.assertNoLogs("models.raw_access", level="WARNING"):
             layouts = message_request_context_project_layouts({}, composer_id="cmp-1")