review: tighten ID + createdAt type gates across the model layer (#30)

Three related CodeRabbit findings, addressed together:

  - Composer.composer_id, Bubble.bubble_id, Workspace.workspace_id now
    require ``isinstance(..., str) and value != ""``. Truthiness alone
    let non-string IDs (e.g. ``123``) slip past the boundary; aligned
    with the pattern already in WorkspaceLocalComposer.

  - Composer.createdAt is now type-gated. Presence was already enforced
    but any value type (e.g. ``"2026-05-12"``) silently became the
    timestamp. Required values must be ``int`` or ``float`` and explicitly
    not ``bool`` (since ``bool`` is a subclass of ``int`` in Python and
    a boolean is never a real timestamp).

Regression tests pin each new gate:

  - test_non_string_composer_id_raises
  - test_non_string_bubble_id_raises
  - test_non_string_workspace_id_raises
  - test_non_numeric_created_at_raises
  - test_numeric_created_at_passes

209 tests pass (was 204; +5 new).

Author: timon0305

models/conversation.py

@@ -26,13 +26,25 @@ def from_dict(cls, raw: dict[str, Any], *, composer_id: str) -> "Composer":
                 "composerData",
                 hint=f"expected object, got {type(raw).__name__}",
             )
-        if not composer_id:
-            raise SchemaError("Composer", "composerId", hint="empty composer ID")
+        if not isinstance(composer_id, str) or not composer_id:
+            raise SchemaError(
+                "Composer",
+                "composerId",
+                hint=f"expected non-empty str, got {type(composer_id).__name__}",
+            )
         if "fullConversationHeadersOnly" not in raw:
             raise SchemaError("Composer", "fullConversationHeadersOnly")
         if "createdAt" not in raw:
             raise SchemaError("Composer", "createdAt")
 
+        created_at = raw.get("createdAt")
+        if not isinstance(created_at, (int, float)) or isinstance(created_at, bool):
+            raise SchemaError(
+                "Composer",
+                "createdAt",
+                hint=f"expected timestamp number, got {type(created_at).__name__}",
+            )
+
         headers = raw.get("fullConversationHeadersOnly")
         if not isinstance(headers, list):
             raise SchemaError(
@@ -48,7 +60,7 @@ def from_dict(cls, raw: dict[str, Any], *, composer_id: str) -> "Composer":
         return cls(
             composer_id=composer_id,
             full_conversation_headers_only=headers,
-            created_at=raw.get("createdAt"),
+            created_at=created_at,
             name=raw.get("name"),
             last_updated_at=raw.get("lastUpdatedAt"),
             model_config=model_config,
@@ -101,6 +113,10 @@ def from_dict(cls, raw: dict[str, Any], *, bubble_id: str) -> "Bubble":
                 "bubble",
                 hint=f"expected object, got {type(raw).__name__}",
             )
-        if not bubble_id:
-            raise SchemaError("Bubble", "bubbleId", hint="empty bubble ID")
+        if not isinstance(bubble_id, str) or not bubble_id:
+            raise SchemaError(
+                "Bubble",
+                "bubbleId",
+                hint=f"expected non-empty str, got {type(bubble_id).__name__}",
+            )
         return cls(bubble_id=bubble_id, raw=raw)

models/workspace.py

@@ -22,8 +22,12 @@ def from_dict(cls, raw: dict[str, Any], *, workspace_id: str) -> "Workspace":
                 "workspace.json",
                 hint=f"expected object, got {type(raw).__name__}",
             )
-        if not workspace_id:
-            raise SchemaError("Workspace", "workspaceId", hint="empty workspace ID")
+        if not isinstance(workspace_id, str) or not workspace_id:
+            raise SchemaError(
+                "Workspace",
+                "workspaceId",
+                hint=f"expected non-empty str, got {type(workspace_id).__name__}",
+            )
         folder = raw.get("folder")
         if folder is not None and not isinstance(folder, str):
             raise SchemaError(

tests/test_models.py

@@ -64,6 +64,12 @@ def test_workspace_parses_with_optional_folder(self) -> None:
         ws_no_folder = Workspace.from_dict({}, workspace_id="cli-only")
         self.assertEqual(ws_no_folder.folder, None)
 
+    def test_non_string_workspace_id_raises(self) -> None:
+        for bad_id in (None, "", 123, [], {}, True, b"bytes"):
+            with self.assertRaises(SchemaError, msg=f"failed for {bad_id!r}") as cm:
+                Workspace.from_dict({}, workspace_id=bad_id)  # type: ignore[arg-type]
+            self.assertEqual(cm.exception.field, "workspaceId")
+
     def test_workspace_local_composer_parses(self) -> None:
         c = WorkspaceLocalComposer.from_dict({
             "composerId": "cid-local-1",
@@ -99,11 +105,30 @@ def test_missing_created_at_raises(self) -> None:
             Composer.from_dict(bad, composer_id="cid-001")
         self.assertEqual(cm.exception.field, "createdAt")
 
+    def test_non_numeric_created_at_raises(self) -> None:
+        for bad_value in ("2026-05-12", None, [], {}, True, False, b"bytes"):
+            bad = dict(GOOD_COMPOSER_RAW, createdAt=bad_value)
+            with self.assertRaises(SchemaError, msg=f"failed for {bad_value!r}") as cm:
+                Composer.from_dict(bad, composer_id="cid-001")
+            self.assertEqual(cm.exception.field, "createdAt")
+
+    def test_numeric_created_at_passes(self) -> None:
+        for ok_value in (1_715_000_000_000, 1_715_000_000_000.5, 0, -1):
+            ok = dict(GOOD_COMPOSER_RAW, createdAt=ok_value)
+            composer = Composer.from_dict(ok, composer_id="cid-001")
+            self.assertEqual(composer.created_at, ok_value)
+
     def test_empty_composer_id_raises(self) -> None:
         with self.assertRaises(SchemaError) as cm:
             Composer.from_dict(GOOD_COMPOSER_RAW, composer_id="")
         self.assertEqual(cm.exception.field, "composerId")
 
+    def test_non_string_composer_id_raises(self) -> None:
+        for bad_id in (None, 123, [], {}, True, b"bytes"):
+            with self.assertRaises(SchemaError, msg=f"failed for {bad_id!r}") as cm:
+                Composer.from_dict(GOOD_COMPOSER_RAW, composer_id=bad_id)  # type: ignore[arg-type]
+            self.assertEqual(cm.exception.field, "composerId")
+
     def test_headers_wrong_type_raises(self) -> None:
         bad = dict(GOOD_COMPOSER_RAW, fullConversationHeadersOnly={"not": "a list"})
         with self.assertRaises(SchemaError) as cm:
@@ -125,6 +150,12 @@ def test_bubble_empty_id_raises(self) -> None:
         with self.assertRaises(SchemaError):
             Bubble.from_dict({"text": "hi"}, bubble_id="")
 
+    def test_non_string_bubble_id_raises(self) -> None:
+        for bad_id in (None, 123, [], {}, True, b"bytes"):
+            with self.assertRaises(SchemaError, msg=f"failed for {bad_id!r}") as cm:
+                Bubble.from_dict({"text": "hi"}, bubble_id=bad_id)  # type: ignore[arg-type]
+            self.assertEqual(cm.exception.field, "bubbleId")
+
     def test_workspace_local_composer_missing_id_raises(self) -> None:
         for bad in (
             {"lastUpdatedAt": 0},           # composerId absent