fix: reviews from the reviewer and ai

Author: bradjin8

api/search.py

@@ -159,7 +159,7 @@ def search():
                         bid = parts[2]
                         try:
                             bubble = Bubble.from_dict(json.loads(row["value"]), bubble_id=bid)
-                            text = extract_text_from_bubble(bubble.raw)
+                            text = extract_text_from_bubble(bubble)
                             bubble_map[bid] = {"text": text, "raw": bubble.raw}
                         except SchemaError as e:
                             # Drift logged so the operator can see why a chat dropped

models/conversation.py

@@ -246,8 +246,18 @@ def context(self) -> dict[str, Any]:
         return value
 
     @property
-    def token_count(self) -> Any | None:
-        return self.raw.get("tokenCount")
+    def token_count(self) -> dict[str, Any] | None:
+        value = self.raw.get("tokenCount")
+        if value is None:
+            return None
+        if not isinstance(value, dict):
+            _logger.warning(
+                "Schema drift in Bubble %s: invalid type for tokenCount (expected dict, got %s)",
+                self.bubble_id,
+                type(value).__name__,
+            )
+            return None
+        return value
 
     @property
     def tool_former_data(self) -> dict[str, Any] | None:
@@ -279,11 +289,23 @@ def model_info(self) -> dict[str, Any]:
 
     @property
     def thinking(self) -> Any | None:
+        if "thinking" not in self.raw:
+            return None
         return self.raw.get("thinking")
 
     @property
-    def thinking_duration_ms(self) -> Any | None:
-        return self.raw.get("thinkingDurationMs")
+    def thinking_duration_ms(self) -> int | float | None:
+        value = self.raw.get("thinkingDurationMs")
+        if value is None:
+            return None
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            _logger.warning(
+                "Schema drift in Bubble %s: invalid type for thinkingDurationMs (expected number, got %s)",
+                self.bubble_id,
+                type(value).__name__,
+            )
+            return None
+        return value
 
     @property
     def context_window_status_at_creation(self) -> dict[str, Any]:

models/raw_access.py

@@ -32,23 +32,35 @@ def optional_raw_value(
     model: str,
     entity_id: str = "",
     expected_type: type[Any] | tuple[type[Any], ...] | None = None,
+    warn_if_missing: bool = True,
 ) -> Any | None:
     """Return ``raw[key]`` when present and typed; log drift and return ``None`` otherwise."""
     if key not in raw:
-        warn_missing_raw_key(raw, key, model=model, entity_id=entity_id)
+        if warn_if_missing:
+            warn_missing_raw_key(raw, key, model=model, entity_id=entity_id)
         return None
     value = raw[key]
-    if expected_type is not None and not isinstance(value, expected_type):
-        suffix = f" {entity_id}" if entity_id else ""
-        _logger.warning(
-            "Schema drift in %s%s: invalid type for %s (expected %s, got %s)",
-            model,
-            suffix,
-            key,
-            expected_type,
-            type(value).__name__,
-        )
-        return None
+    if expected_type is not None:
+        if isinstance(value, bool) and expected_type in ((int, float), int, float):
+            suffix = f" {entity_id}" if entity_id else ""
+            _logger.warning(
+                "Schema drift in %s%s: invalid type for %s (expected number, got bool)",
+                model,
+                suffix,
+                key,
+            )
+            return None
+        if not isinstance(value, expected_type):
+            suffix = f" {entity_id}" if entity_id else ""
+            _logger.warning(
+                "Schema drift in %s%s: invalid type for %s (expected %s, got %s)",
+                model,
+                suffix,
+                key,
+                expected_type,
+                type(value).__name__,
+            )
+            return None
     return value
 
 
@@ -58,13 +70,15 @@ def optional_raw_list(
     *,
     model: str,
     entity_id: str = "",
+    warn_if_missing: bool = True,
 ) -> list[Any] | None:
     return optional_raw_value(
         raw,
         key,
         model=model,
         entity_id=entity_id,
         expected_type=list,
+        warn_if_missing=warn_if_missing,
     )
 
 
@@ -74,16 +88,66 @@ def optional_raw_dict(
     *,
     model: str,
     entity_id: str = "",
+    warn_if_missing: bool = True,
 ) -> dict[str, Any] | None:
     return optional_raw_value(
         raw,
         key,
         model=model,
         entity_id=entity_id,
         expected_type=dict,
+        warn_if_missing=warn_if_missing,
     )
 
 
+def _optional_list_absent_ok(
+    raw: dict[str, Any],
+    key: str,
+    *,
+    model: str,
+    entity_id: str = "",
+) -> list[Any]:
+    """List field often omitted by Cursor; warn only on wrong type."""
+    value = raw.get(key)
+    if value is None:
+        return []
+    if not isinstance(value, list):
+        suffix = f" {entity_id}" if entity_id else ""
+        _logger.warning(
+            "Schema drift in %s%s: invalid type for %s (expected list, got %s)",
+            model,
+            suffix,
+            key,
+            type(value).__name__,
+        )
+        return []
+    return value
+
+
+def _optional_dict_absent_ok(
+    raw: dict[str, Any],
+    key: str,
+    *,
+    model: str,
+    entity_id: str = "",
+) -> dict[str, Any] | None:
+    """Dict field often omitted; warn only on wrong type; ``None`` when absent."""
+    value = raw.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, dict):
+        suffix = f" {entity_id}" if entity_id else ""
+        _logger.warning(
+            "Schema drift in %s%s: invalid type for %s (expected dict, got %s)",
+            model,
+            suffix,
+            key,
+            type(value).__name__,
+        )
+        return None
+    return value
+
+
 def optional_raw_str(
     raw: dict[str, Any],
     key: str,
@@ -100,29 +164,28 @@ def optional_raw_str(
     )
 
 
-def optional_raw_number(
+def _optional_str_absent_ok(
     raw: dict[str, Any],
     key: str,
     *,
     model: str,
     entity_id: str = "",
-    default: int | float = 0,
-) -> int | float:
-    """Numeric composer counters; warn on missing key, return *default* when absent."""
-    if key not in raw:
-        warn_missing_raw_key(raw, key, model=model, entity_id=entity_id)
-        return default
-    value = raw[key]
-    if isinstance(value, bool) or not isinstance(value, (int, float)):
-        suffix = f" {entity_id}" if entity_id else ""
-        _logger.warning(
-            "Schema drift in %s%s: invalid type for %s (expected number, got %s)",
-            model,
-            suffix,
-            key,
-            type(value).__name__,
-        )
-        return default
+) -> str | None:
+    """String field often omitted on headers; warn only on wrong type."""
+    value = raw.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, str) or not value:
+        if key in raw:
+            suffix = f" {entity_id}" if entity_id else ""
+            _logger.warning(
+                "Schema drift in %s%s: invalid type for %s (expected non-empty str, got %s)",
+                model,
+                suffix,
+                key,
+                type(value).__name__,
+            )
+        return None
     return value
 
 
@@ -132,13 +195,12 @@ def conversation_header_bubble_id(
     composer_id: str = "",
 ) -> str | None:
     """``bubbleId`` from a ``fullConversationHeadersOnly`` entry."""
-    value = optional_raw_str(
+    return _optional_str_absent_ok(
         header,
         "bubbleId",
         model="ConversationHeader",
         entity_id=composer_id,
     )
-    return value if value else None
 
 
 def message_request_context_project_layouts(
@@ -152,6 +214,7 @@ def message_request_context_project_layouts(
         "projectLayouts",
         model="MessageRequestContext",
         entity_id=composer_id,
+        warn_if_missing=False,
     )
 
 
@@ -165,44 +228,41 @@ def composer_headers(
         return data.full_conversation_headers_only
     if not isinstance(data, dict):
         return []
-    value = data.get("fullConversationHeadersOnly")
-    if value is None:
-        return []
-    if not isinstance(value, list):
-        _logger.warning(
-            "Schema drift in Composer %s: invalid type for fullConversationHeadersOnly (expected list, got %s)",
-            composer_id,
-            type(value).__name__,
-        )
-        return []
-    return value
+    return _optional_list_absent_ok(
+        data,
+        "fullConversationHeadersOnly",
+        model="Composer",
+        entity_id=composer_id,
+    )
 
 
 def composer_newly_created_files(data: Any, composer_id: str) -> list[Any]:
     from models.conversation import Composer
 
     if isinstance(data, Composer):
         return data.newly_created_files
-    value = data.get("newlyCreatedFiles") if isinstance(data, dict) else None
-    if value is None:
-        return []
-    if not isinstance(value, list):
-        _logger.warning(
-            "Schema drift in Composer %s: invalid type for newlyCreatedFiles (expected list, got %s)",
-            composer_id,
-            type(value).__name__,
-        )
+    if not isinstance(data, dict):
         return []
-    return value
+    return _optional_list_absent_ok(
+        data,
+        "newlyCreatedFiles",
+        model="Composer",
+        entity_id=composer_id,
+    )
 
 
 def composer_code_block_data(data: Any, composer_id: str) -> dict[str, Any] | None:
     from models.conversation import Composer
 
     if isinstance(data, Composer):
         return data.code_block_data
-    return optional_raw_dict(
-        data, "codeBlockData", model="Composer", entity_id=composer_id
+    if not isinstance(data, dict):
+        return None
+    return _optional_dict_absent_ok(
+        data,
+        "codeBlockData",
+        model="Composer",
+        entity_id=composer_id,
     )
 
 
@@ -212,13 +272,12 @@ def bubble_relevant_files(bubble: Any, bubble_id: str = "") -> list[Any]:
     if isinstance(bubble, Bubble):
         return bubble.relevant_files
     if isinstance(bubble, dict):
-        files = optional_raw_list(
+        return _optional_list_absent_ok(
             bubble,
             "relevantFiles",
             model="Bubble",
             entity_id=bubble_id,
         )
-        return files if files is not None else []
     return []
 
 
@@ -228,13 +287,12 @@ def bubble_attached_file_uris(bubble: Any, bubble_id: str = "") -> list[Any]:
     if isinstance(bubble, Bubble):
         return bubble.attached_file_code_chunks_uris
     if isinstance(bubble, dict):
-        uris = optional_raw_list(
+        return _optional_list_absent_ok(
             bubble,
             "attachedFileCodeChunksUris",
             model="Bubble",
             entity_id=bubble_id,
         )
-        return uris if uris is not None else []
     return []
 
 
@@ -244,7 +302,7 @@ def bubble_context(bubble: Any, bubble_id: str = "") -> dict[str, Any]:
     if isinstance(bubble, Bubble):
         return bubble.context
     if isinstance(bubble, dict):
-        ctx = optional_raw_dict(
+        ctx = _optional_dict_absent_ok(
             bubble,
             "context",
             model="Bubble",