Please address the comments from this code review:

## Overall Comments
- Now that both `_encode_image_bs64` and `encode_image_bs64` always delegate to `image_source_to_data_uri` (which never returns an empty string), the `if not image_data` branches in the context assembly logic have effectively become dead code and can be removed or adjusted to only handle exception cases.
- In `image_source_to_data_uri`, you explicitly reject `http(s)` URLs while the callers still use a simple `startswith("http")` check, which can be brittle (e.g. uppercase schemes or other `http`-prefixed schemes); consider aligning the scheme detection logic between the helper and its callers, or centralizing the scheme handling in one place to avoid edge-case mismatches.

Please address the comments from this code review:

## Individual Comments

### Comment 1
<location path="astrbot/core/utils/io.py" line_range="255-261" />
<code_context>
+            "Remote image URL is not supported in image_source_to_data_uri; download the file before calling this helper.",
+        )
+
+    if image_source.startswith("base64://"):
+        raw_base64 = image_source.removeprefix("base64://")
+        mime_type = DEFAULT_IMAGE_MIME_TYPE
+        try:
+            image_bytes = base64.b64decode(raw_base64)
+            mime_type = detect_image_mime_type(image_bytes)
+        except Exception:
+            pass
+        return f"data:{mime_type};base64,{raw_base64}", mime_type
</code_context>
<issue_to_address>
**suggestion (bug_risk):** base64:// handling swallows all decode errors and still returns the original base64 without any signal.

Decoding errors for `base64://` are caught with a bare `Exception`, and you then return the original `raw_base64` with a default MIME. This makes invalid base64 indistinguishable from a valid non-JPEG image and may hide unrelated failures. Please narrow the exception to the specific decode errors (e.g., `binascii.Error`/`ValueError`), and consider logging at debug level or skipping `detect_image_mime_type` entirely when decode fails so the behavior is explicit.

Suggested implementation:

```python
    if image_source.startswith("base64://"):
        raw_base64 = image_source.removeprefix("base64://")
        mime_type = DEFAULT_IMAGE_MIME_TYPE

        try:
            image_bytes = base64.b64decode(raw_base64)
        except (binascii.Error, ValueError) as exc:
            # Invalid base64 payload: keep the default MIME type and skip detection.
            # This keeps the behavior explicit and does not hide non-base64 related errors.
            try:
                logger.debug("Failed to decode base64 image_source: %s", exc)
            except NameError:
                # logger may not be defined in all usages; fail silently if absent.
                pass
            return f"data:{mime_type};base64,{raw_base64}", mime_type

        try:
            mime_type = detect_image_mime_type(image_bytes)
        except Exception:
            # If MIME detection fails, fall back to the default type but still
            # return the original base64 content.
            try:
                logger.debug("Failed to detect MIME type for base64 image_source", exc_info=True)
            except NameError:
                pass

        return f"data:{mime_type};base64,{raw_base64}", mime_type

```

To fully integrate this change with the rest of the module, you should:

1. Add the missing imports at the top of `astrbot/core/utils/io.py` (if they are not already present):

   ```python
   import binascii
   import logging

   logger = logging.getLogger(__name__)
   ```

2. If your project uses a different logging convention (e.g., a shared logger utility), replace the `logger` usage here with that project-standard logger to keep logging consistent across the codebase.
</issue_to_address>

Please address the comments from this code review:

## Overall Comments
- In `image_source_to_data_uri`, `base64://` and `file://` handling is case-sensitive while HTTP(S) detection is case-insensitive; consider using `lower_source` for these checks as well so `BASE64://` and `FILE://` variants behave consistently.
- When decoding `base64://` sources, you already catch `binascii.Error`/`ValueError`; using `base64.b64decode(raw_base64, validate=True)` would make invalid base64 detection stricter and avoid silently accepting malformed input.