hookbell 0.1.0__tar.gz

hookbell-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yukihiko Shinoda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hookbell-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include docs *

hookbell-0.1.0/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: hookbell
+Version: 0.1.0
+Summary: Notifies Slack, as a Claude Code hook or as a notify-compatible CLI.
+Author-email: Yukihiko Shinoda <yuk.hik.future@gmail.com>
+Maintainer-email: Yukihiko Shinoda <yuk.hik.future@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Yukihiko Shinoda
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: homepage, https://github.com/yukihiko-shinoda/hookbell
+Project-URL: repository, https://github.com/yukihiko-shinoda/hookbell
+Keywords: hookbell
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Communications :: Chat
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: certifi>=2026.7.22
+Requires-Dist: click>=7.0
+Dynamic: license-file
+
+# Hookbell
+
+[![Test](https://github.com/yukihiko-shinoda/hookbell/workflows/Test/badge.svg)](https://github.com/yukihiko-shinoda/hookbell/actions?query=workflow%3ATest)
+[![CodeQL](https://github.com/yukihiko-shinoda/hookbell/workflows/CodeQL/badge.svg)](https://github.com/yukihiko-shinoda/hookbell/actions?query=workflow%3ACodeQL)
+[![Code Coverage](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell/coverage.svg)](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell)
+[![Maintainability](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell/maintainability.svg)](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell)
+[![Dependabot](https://flat.badgen.net/github/dependabot/yukihiko-shinoda/hookbell?icon=dependabot)](https://github.com/yukihiko-shinoda/hookbell/security/dependabot)
+[![Python versions](https://img.shields.io/pypi/pyversions/hookbell)](https://pypi.org/project/hookbell/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/hookbell)](https://pypi.org/project/hookbell/)
+[![X URL](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Fgithub.com%2Fyukihiko-shinoda%2Fhookbell)](https://x.com/intent/post?text=Hookbell&url=https%3A%2F%2Fpypi.org%2Fproject%2Fhookbell%2F&hashtags=python)
+
+Notifies Slack — as a Claude Code hook, or as a general "notify me when this finishes" command for
+any piped output.
+
+## Advantage
+
+A Claude Code hook script that only understands its own hook JSON payload
+(`transcript_path`, `hook_event_name`, ...) can't double as a general-purpose notification command
+for anything else you run — and a general-purpose command built without Claude Code in mind knows
+nothing about its transcripts, so it can't report what the assistant actually said or which
+permission it's waiting on. Maintaining one script per use case means duplicating the Slack-posting
+logic each time.
+
+Hookbell covers both with a single command: it inspects stdin and automatically picks the right
+behavior. A Claude Code hook payload gets reported through its referenced transcript; anything else
+is treated as free-form piped text and posted as-is.
+
+## Quickstart
+
+```bash
+uv tool install hookbell
+```
+
+Set the webhook URL from a Slack [Incoming Webhook](https://api.slack.com/messaging/webhooks):
+
+```bash
+export SLACK_WEBHOOK_URL="https://hooks.slack.com/services/T000/B000/XXXX"
+```
+
+Pipe any text into hookbell to post it to Slack:
+
+```bash
+echo 'Hello world' | uvx hookbell
+```
+
+That posts this single Slack message:
+
+````text
+Finished!
+```
+Hello world
+```
+````
+
+Since any piped input gets wrapped the same way, piping a long-running command's own output into
+hookbell delivers that output to Slack the moment the command is done, without having to watch the
+terminal for it — redirecting stderr into stdout matters here, since build tools like
+`docker compose build` write their progress there:
+
+```bash
+docker compose build 2>&1 | uvx hookbell
+```
+
+When the command's output isn't worth forwarding and only knowing it ended matters, chaining with
+`;` instead leaves hookbell's stdin empty, so it just posts `Finished!` on its own:
+
+```bash
+docker compose build; uvx hookbell
+```
+
+<!-- markdownlint-disable no-trailing-punctuation -->
+## How do I...
+<!-- markdownlint-enable no-trailing-punctuation -->
+
+### How do I use hookbell as a Claude Code hook?
+
+Point Claude Code's `Notification`, `PermissionRequest`, and `Stop` hooks at hookbell in
+`settings.json`:
+
+```json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "hooks": [{ "type": "command", "command": "uvx hookbell" }]
+      }
+    ]
+  }
+}
+```
+
+Hookbell recognizes a Claude Code hook payload by its `transcript_path` field and posts a message
+built from that transcript: the assistant's own last message when there is one, or a description of
+the pending permission request otherwise. A failed notification here is logged (see `slack.log`)
+rather than raised, so a flaky network never turns into hook-failure noise.
+
+### How do I use hookbell in a Docker container?
+
+Hookbell checks `/run/secrets/slack_webhook_url` before falling back to `SLACK_WEBHOOK_URL`, so a
+[Docker secret] keeps the webhook URL out of the container's environment and image layers entirely.
+With Compose, write the URL to a local file Compose reads at build/run time, and mount it as a
+secret named `slack_webhook_url` so Docker places it at that exact path:
+
+```yaml
+services:
+  app:
+    secrets:
+      - slack_webhook_url
+
+secrets:
+  slack_webhook_url:
+    file: ./slack_webhook_url.txt
+```
+
+[Docker secret]: https://docs.docker.com/compose/how-tos/use-secrets/
+
+## Credits
+
+This package was created with [Cookiecutter] and the [yukihiko-shinoda/cookiecutter-pypackage] project template.
+
+[Cookiecutter]: https://github.com/audreyr/cookiecutter
+[yukihiko-shinoda/cookiecutter-pypackage]: https://github.com/audreyr/cookiecutter-pypackage

hookbell-0.1.0/README.md

@@ -0,0 +1,122 @@
+# Hookbell
+
+[![Test](https://github.com/yukihiko-shinoda/hookbell/workflows/Test/badge.svg)](https://github.com/yukihiko-shinoda/hookbell/actions?query=workflow%3ATest)
+[![CodeQL](https://github.com/yukihiko-shinoda/hookbell/workflows/CodeQL/badge.svg)](https://github.com/yukihiko-shinoda/hookbell/actions?query=workflow%3ACodeQL)
+[![Code Coverage](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell/coverage.svg)](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell)
+[![Maintainability](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell/maintainability.svg)](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell)
+[![Dependabot](https://flat.badgen.net/github/dependabot/yukihiko-shinoda/hookbell?icon=dependabot)](https://github.com/yukihiko-shinoda/hookbell/security/dependabot)
+[![Python versions](https://img.shields.io/pypi/pyversions/hookbell)](https://pypi.org/project/hookbell/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/hookbell)](https://pypi.org/project/hookbell/)
+[![X URL](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Fgithub.com%2Fyukihiko-shinoda%2Fhookbell)](https://x.com/intent/post?text=Hookbell&url=https%3A%2F%2Fpypi.org%2Fproject%2Fhookbell%2F&hashtags=python)
+
+Notifies Slack — as a Claude Code hook, or as a general "notify me when this finishes" command for
+any piped output.
+
+## Advantage
+
+A Claude Code hook script that only understands its own hook JSON payload
+(`transcript_path`, `hook_event_name`, ...) can't double as a general-purpose notification command
+for anything else you run — and a general-purpose command built without Claude Code in mind knows
+nothing about its transcripts, so it can't report what the assistant actually said or which
+permission it's waiting on. Maintaining one script per use case means duplicating the Slack-posting
+logic each time.
+
+Hookbell covers both with a single command: it inspects stdin and automatically picks the right
+behavior. A Claude Code hook payload gets reported through its referenced transcript; anything else
+is treated as free-form piped text and posted as-is.
+
+## Quickstart
+
+```bash
+uv tool install hookbell
+```
+
+Set the webhook URL from a Slack [Incoming Webhook](https://api.slack.com/messaging/webhooks):
+
+```bash
+export SLACK_WEBHOOK_URL="https://hooks.slack.com/services/T000/B000/XXXX"
+```
+
+Pipe any text into hookbell to post it to Slack:
+
+```bash
+echo 'Hello world' | uvx hookbell
+```
+
+That posts this single Slack message:
+
+````text
+Finished!
+```
+Hello world
+```
+````
+
+Since any piped input gets wrapped the same way, piping a long-running command's own output into
+hookbell delivers that output to Slack the moment the command is done, without having to watch the
+terminal for it — redirecting stderr into stdout matters here, since build tools like
+`docker compose build` write their progress there:
+
+```bash
+docker compose build 2>&1 | uvx hookbell
+```
+
+When the command's output isn't worth forwarding and only knowing it ended matters, chaining with
+`;` instead leaves hookbell's stdin empty, so it just posts `Finished!` on its own:
+
+```bash
+docker compose build; uvx hookbell
+```
+
+<!-- markdownlint-disable no-trailing-punctuation -->
+## How do I...
+<!-- markdownlint-enable no-trailing-punctuation -->
+
+### How do I use hookbell as a Claude Code hook?
+
+Point Claude Code's `Notification`, `PermissionRequest`, and `Stop` hooks at hookbell in
+`settings.json`:
+
+```json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "hooks": [{ "type": "command", "command": "uvx hookbell" }]
+      }
+    ]
+  }
+}
+```
+
+Hookbell recognizes a Claude Code hook payload by its `transcript_path` field and posts a message
+built from that transcript: the assistant's own last message when there is one, or a description of
+the pending permission request otherwise. A failed notification here is logged (see `slack.log`)
+rather than raised, so a flaky network never turns into hook-failure noise.
+
+### How do I use hookbell in a Docker container?
+
+Hookbell checks `/run/secrets/slack_webhook_url` before falling back to `SLACK_WEBHOOK_URL`, so a
+[Docker secret] keeps the webhook URL out of the container's environment and image layers entirely.
+With Compose, write the URL to a local file Compose reads at build/run time, and mount it as a
+secret named `slack_webhook_url` so Docker places it at that exact path:
+
+```yaml
+services:
+  app:
+    secrets:
+      - slack_webhook_url
+
+secrets:
+  slack_webhook_url:
+    file: ./slack_webhook_url.txt
+```
+
+[Docker secret]: https://docs.docker.com/compose/how-tos/use-secrets/
+
+## Credits
+
+This package was created with [Cookiecutter] and the [yukihiko-shinoda/cookiecutter-pypackage] project template.
+
+[Cookiecutter]: https://github.com/audreyr/cookiecutter
+[yukihiko-shinoda/cookiecutter-pypackage]: https://github.com/audreyr/cookiecutter-pypackage

hookbell-0.1.0/docs/CONTRIBUTING.md

@@ -0,0 +1,133 @@
+# Contributing
+
+Contributions are welcome, and they are greatly appreciated! Every little bit
+helps, and credit will always be given.
+
+You can contribute in many ways:
+
+## Types of Contributions
+
+### Report Bugs
+
+Report bugs at [GitHub Issues].
+
+If you are reporting a bug, please include:
+
+- Your operating system name and version.
+- Any details about your local setup that might be helpful in troubleshooting.
+- Detailed steps to reproduce the bug.
+
+### Fix Bugs
+
+Look through the GitHub issues for bugs. Anything tagged with "bug" and "help
+wanted" is open to whoever wants to implement it.
+
+### Implement Features
+
+Look through the GitHub issues for features. Anything tagged with "enhancement"
+and "help wanted" is open to whoever wants to implement it.
+
+### Write Documentation
+
+Hookbell could always use more documentation, whether as part of the
+official Hookbell docs, in docstrings, or even on the web in blog posts,
+articles, and such.
+
+### Submit Feedback
+
+The best way to send feedback is to file an issue at  [GitHub Issues].
+
+If you are proposing a feature:
+
+- Explain in detail how it would work.
+- Keep the scope as narrow as possible, to make it easier to implement.
+- Remember that this is a volunteer-driven project, and that contributions
+  are welcome :)
+
+<!-- markdownlint-disable no-trailing-punctuation -->
+## Get Started!
+<!-- markdownlint-enaable no-trailing-punctuation -->
+
+Ready to contribute? Here's how to set up `Hookbell` for local development.
+
+1. Fork the `hookbell` repo on GitHub.
+2. Clone your fork locally:
+
+   ```console
+   git clone git@github.com:your_name_here/hookbell.git
+   ```
+
+3. Set up your development environment.
+
+   The recommended way is to use [docker-compose-python-development](https://github.com/yukihiko-shinoda/docker-compose-python-development),
+   which provides a pre-configured Docker-based environment for Python projects.
+   Follow the setup instructions in that repository, then clone this repo into its workspace.
+
+   Alternatively, install dependencies directly with `uv`:
+
+   ```console
+   uv sync
+   ```
+
+4. Create a branch for local development:
+
+   ```console
+   git checkout -b name-of-your-bugfix-or-feature
+   ```
+
+   Now you can make your changes locally.
+
+5. When you're done making changes,
+   check that your changes pass Ruff, docformatter,
+   and the tests, including testing oldest Python version:
+
+   ```console
+   uv run inv style --check
+   uv run pytest
+   uv install --python 3.7
+   uv run pytest
+   ```
+
+6. Commit your changes and push your branch to GitHub:
+
+   ```console
+   git add .
+   git commit -m "Your detailed description of your changes."
+   git push origin name-of-your-bugfix-or-feature
+   ```
+
+7. Submit a pull request through the GitHub website.
+
+## Pull Request Guidelines
+
+Before you submit a pull request, check that it meets these guidelines:
+
+1. The pull request should include tests.
+2. If the pull request adds functionality, the docs should be updated. Put
+   your new functionality into a function with a docstring, and add the
+   feature to the list in README.md.
+
+## Tips
+
+To run a subset of tests:
+
+```console
+uv run pytest tests.test_hookbell
+
+```
+
+## Deploying
+
+A reminder for the maintainers on how to deploy.
+Make sure all your changes are committed.
+Then run:
+
+```console
+bump2version patch # possible: major / minor / patch
+git push
+git push --tags
+```
+
+Travis will then deploy to PyPI if tests pass.
+
+[GitHub Issues]: https://github.com/yukihiko-shinoda/hookbell/issues

hookbell-0.1.0/hookbell/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Top-level package for Hookbell."""
+
+__author__ = """Yukihiko Shinoda"""
+__email__ = "yuk.hik.future@gmail.com"
+__version__ = "0.1.0"

hookbell-0.1.0/hookbell/claude_code/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Claude Code hook payload handling."""

hookbell-0.1.0/hookbell/claude_code/event.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Composes a notification text from a Claude Code hook event."""
+
+from hookbell.claude_code.stdin import ClaudeCodeStdin
+from hookbell.claude_code.transcript import Transcript
+
+
+class ClaudeCodeHookEvent:
+    """A Claude Code hook event, combining its stdin payload and referenced transcript."""
+
+    def __init__(self, stdin: ClaudeCodeStdin) -> None:
+        self.stdin = stdin
+        self.transcript = Transcript(stdin.transcript_path)
+
+    @property
+    def text(self) -> str:
+        """Return the notification text for this hook event."""
+        content = self.transcript.text_content or self.stdin.fallback_text
+        return f"{content}\n\nMessage type: {self.stdin.message}\n\n```{self.transcript.report()}```"

hookbell-0.1.0/hookbell/claude_code/stdin.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Parses Claude Code hook stdin payloads."""
+
+from __future__ import annotations
+
+import json
+from logging import getLogger
+from pathlib import Path
+from typing import Any
+
+
+class ClaudeCodeStdin:
+    """A Claude Code hook stdin payload."""
+
+    TRANSCRIPT_PATH_KEY = "transcript_path"
+
+    def __init__(self, data: dict[str, Any]) -> None:
+        self.data = data
+
+    @classmethod
+    def parse(cls, raw_stdin: str) -> ClaudeCodeStdin | None:
+        """Return a ClaudeCodeStdin when raw_stdin holds a Claude Code hook payload, else None."""
+        try:
+            data = json.loads(raw_stdin)
+        except json.JSONDecodeError:
+            return None
+        if not isinstance(data, dict) or cls.TRANSCRIPT_PATH_KEY not in data:
+            return None
+        getLogger(__name__).debug("raw stdin: %s", raw_stdin)
+        return cls(data)
+
+    @property
+    def message(self) -> str:
+        """Return the hook's message, falling back to its event name."""
+        return str(self.data.get("message") or self.data.get("hook_event_name", "Notification"))
+
+    @property
+    def transcript_path(self) -> Path:
+        """Return the transcript file path this hook event refers to."""
+        return Path(self.data[self.TRANSCRIPT_PATH_KEY])
+
+    @property
+    def fallback_text(self) -> str:
+        """Return text to show when the transcript's last line has no readable text.
+
+        PermissionRequest payloads carry the pending tool call directly instead of assistant text, and Stop payloads
+        carry a ready-made last_assistant_message when the transcript's last line was something else (e.g. a sidechain
+        or summary entry).
+        """
+        last_assistant_message = self.data.get("last_assistant_message")
+        if last_assistant_message:
+            return str(last_assistant_message)
+        tool_name = self.data.get("tool_name")
+        if tool_name:
+            tool_input = json.dumps(self.data.get("tool_input", {}), ensure_ascii=False)
+            return f"Waiting for permission: {tool_name}({tool_input})"
+        return self.message

hookbell-0.1.0/hookbell/claude_code/transcript.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Reads and sanitizes a Claude Code transcript's last entry."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import TYPE_CHECKING
+from typing import Any
+
+if TYPE_CHECKING:
+    import io
+    from pathlib import Path
+
+
+class FileLastLineGetter:
+    """Gets the last line of a file without reading the whole file into memory."""
+
+    def __init__(self, file_path: Path) -> None:
+        self.file_path = file_path
+
+    def get_last_line(self) -> str:
+        """Return the last line of the file."""
+        with self.file_path.open("rb") as file_pointer:
+            return self._get_last_line(file_pointer)
+
+    @staticmethod
+    def _get_last_line(file_pointer: io.BufferedIOBase) -> str:
+        try:
+            FileLastLineGetter._seek_to_last_new_line(file_pointer)
+        except OSError:
+            # In case of a one line file
+            file_pointer.seek(0)
+        return file_pointer.readline().decode("utf-8").strip()
+
+    @staticmethod
+    def _seek_to_last_new_line(file_pointer: io.BufferedIOBase) -> None:
+        file_pointer.seek(-2, os.SEEK_END)
+        while file_pointer.read(1) != b"\n":
+            file_pointer.seek(-2, os.SEEK_CUR)
+
+
+class Transcript:
+    """A Claude Code transcript.
+
+    The transcript's last line is not always a plain assistant text message: it may be a tool call, a sub-
+    agent/sidechain entry, or a compaction summary entry, each with a different shape. Every accessor here must
+    tolerate keys being absent rather than assume the full schema.
+    """
+
+    UNREADABLE_KEYS = ("parentUuid", "isSidechain", "sessionId", "version", "requestId", "uuid", "timestamp")
+
+    def __init__(self, path: Path) -> None:
+        transcript_json_string = FileLastLineGetter(path).get_last_line()
+        self.data: Any = json.loads(transcript_json_string)
+
+    def report(self) -> str:
+        """Return the last transcript entry as pretty-printed, sanitized JSON."""
+        return json.dumps(self._remove_unreadable_keys(), indent=2, ensure_ascii=False)
+
+    def _remove_unreadable_keys(self) -> dict[str, Any]:
+        if not isinstance(self.data, dict):
+            return {"raw": self.data}
+        data = self.data.copy()
+        for key in self.UNREADABLE_KEYS:
+            data.pop(key, None)
+        message = data.get("message")
+        if isinstance(message, dict):
+            self._remove_unreadable_message_keys(message)
+        return data
+
+    @staticmethod
+    def _remove_unreadable_message_keys(message: dict[str, Any]) -> None:
+        message.pop("id", None)
+        for message_content in message.get("content") or []:
+            if isinstance(message_content, dict):
+                message_content.pop("id", None)
+
+    @property
+    def text_content(self) -> str:
+        """Return the concatenated assistant text blocks of the last transcript entry."""
+        if not isinstance(self.data, dict):
+            return ""
+        contents = self.data.get("message", {}).get("content") or []
+        if not isinstance(contents, list):
+            return ""
+        texts = [item["text"] for item in contents if isinstance(item, dict) and item.get("type") == "text"]
+        return "\n".join(texts)