md2speech 0.1.0__tar.gz

md2speech-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Run unit tests
+        run: pytest -m "not integration"

md2speech-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,57 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Run unit tests
+        run: pytest -m "not integration"
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/md2speech/
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: python -m pip install --upgrade pip build
+
+      - name: Build wheel and sdist
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+          files: dist/*

md2speech-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+.venv/
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.coverage
+htmlcov/
+*.mp3
+*.wav
+.DS_Store
+dist/
+build/
+.pytest_cache/
+.coverage
+htmlcov/
+*.mp3
+*.wav
+.DS_Store

md2speech-0.1.0/.markdownlint.json

@@ -0,0 +1,3 @@
+{
+    "default": false
+}

md2speech-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

md2speech-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 md2speech contributors
+
+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.

md2speech-0.1.0/MARKDOWN_TTS_PACKAGE_AGENT.md

@@ -0,0 +1,520 @@
+# Agent Prompt: Standalone Markdown/Text-to-Speech Python Package
+
+> **Generated:** 2026-07-08  
+> **Purpose:** Implement a **completely independent** Python package (no DriveSpeak code, imports, or repo coupling) that converts Markdown or plain-text files to speech audio using the same **free, local** TTS stack as DriveSpeak: **Kokoro-82M** via the `kokoro` Python package.  
+> **Reference only:** A prior analysis of DriveSpeak's TTS pipeline is summarized in §3 below. Use it as architectural guidance — do **not** copy DriveSpeak source files or depend on `drivespeak_ml`.
+
+---
+
+## How to Use This Prompt
+
+This is a single deliverable: a new, self-contained Python package with CLI, library API, tests, and user documentation. Execute the phases in order. Verify acceptance criteria after each phase before proceeding.
+
+```
+Phase 1 — Project scaffold & packaging
+Phase 2 — Text ingestion (Markdown + plain text)
+Phase 3 — TTS engine (Kokoro) & long-text synthesis
+Phase 4 — Audio post-processing & format conversion
+Phase 5 — CLI & library public API
+Phase 6 — Tests, docs, and install verification
+```
+
+**Critical rules:**
+
+1. The package must be **fully standalone** — installable via `pip install .` or `uv sync` from its own directory, with zero references to DriveSpeak paths, modules, or configs.
+2. **Default engine is Kokoro only** — free, local, offline. Do not add paid API dependencies (ElevenLabs, OpenAI TTS, etc.).
+3. **First-run experience must work** — installation pulls Python dependencies; model weights download automatically on first synthesis (via `huggingface-hub`, as Kokoro does).
+4. **Default output format is MP3** — the package must handle encoding itself (not require the user to run external tools manually).
+5. Write **comprehensive user documentation** in `README.md` (see §8).
+
+---
+
+## 1. Product Requirements
+
+### 1.1 CLI Interface
+
+Implement a console script (e.g. `md2speech` or `text2speech` — choose a clear, memorable name and use it consistently).
+
+**Required positional argument:**
+
+| Argument | Description |
+|----------|-------------|
+| `input` | Path to a `.md`, `.markdown`, or `.txt` file |
+
+**Optional arguments:**
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--output` / `-o` | Derived from input filename | Output audio file path |
+| `--format` / `-f` | `mp3` | Output audio format (see §1.3) |
+| `--voice` / `-v` | `af_heart` | Kokoro voice ID (document available voices) |
+| `--speed` | `1.0` | Speech speed multiplier |
+| `--lang` | `a` | Kokoro language code (`a` = American English) |
+| `--no-normalize` | off | Skip text normalization (numbers, abbreviations, etc.) |
+| `--paragraph-pause` | `0.4` | Seconds of silence between paragraphs |
+| `--verbose` / `-v` (or `-V` if `-v` is voice) | off | Enable debug logging |
+
+**Default output path logic** (when `--output` is omitted):
+
+- Same directory as the input file
+- Basename matches input basename
+- Extension matches `--format` (e.g. `article.md` → `article.mp3`)
+
+**Example invocations** (must work after install):
+
+```bash
+# Minimal — converts article.md → article.mp3 in the same folder
+md2speech article.md
+
+# Explicit output path and format
+md2speech chapter.txt -o ~/Audio/chapter.wav --format wav
+
+# Long Markdown document with a specific voice
+md2speech book.md -o book.mp3 --voice am_adam --speed 0.95
+```
+
+### 1.2 Library API
+
+Expose a clean Python API (not only CLI) so the package can be imported:
+
+```python
+from <package_name> import synthesize_file
+
+result = synthesize_file(
+    "article.md",
+    output_path="article.mp3",   # optional
+    output_format="mp3",         # optional, default "mp3"
+    voice="af_heart",
+    speed=1.0,
+)
+# result.path → Path to written audio file
+# result.duration_seconds → float
+```
+
+Also expose lower-level building blocks (`read_document`, `extract_plain_text`, `TTSEngine`, `AudioWriter`) for advanced users. Document all public symbols.
+
+### 1.3 Supported Output Formats
+
+| Format | Required | Notes |
+|--------|----------|-------|
+| `mp3` | **Yes (default)** | Primary delivery format |
+| `wav` | Yes | Uncompressed PCM |
+| `ogg` | Nice to have | Vorbis via pydub/ffmpeg |
+| `flac` | Nice to have | Lossless |
+
+Implementation: use **`pydub`** (backed by **ffmpeg**) for MP3/OGG/FLAC encoding. Declare `ffmpeg` as a **system prerequisite** in the README and detect it at runtime with a clear error message if missing.
+
+For WAV, write directly with `soundfile` (no ffmpeg needed). For MP3 and other compressed formats, pydub/ffmpeg is the standard approach.
+
+### 1.4 Input File Handling
+
+**Plain text (`.txt`):** Read as UTF-8. Handle BOM if present.
+
+**Markdown (`.md`, `.markdown`):**
+
+1. Read as UTF-8.
+2. Strip YAML front matter if present (`---` delimited block at top).
+3. Convert Markdown to plain speakable text:
+   - Remove or ignore HTML comments.
+   - Strip inline/formatting markup (bold, italic, links → link text only, code spans → speak the code text or skip fenced code blocks — **document the choice**; prefer skipping fenced code blocks and speaking inline code literally).
+   - Convert headings to plain text (do not say "hash hash heading").
+   - Preserve paragraph breaks (`\n\n`) for natural pacing.
+   - Preserve list items as speakable lines.
+4. Do **not** require a full Markdown renderer with network access. Use a lightweight approach (`markdown-it-py`, `mistune`, or regex-based stripping). Keep dependencies minimal.
+
+Reject unsupported extensions with a clear error.
+
+---
+
+## 2. Technical Architecture
+
+### 2.1 Recommended Package Layout
+
+Create the package in a **new top-level directory** inside the workspace (sibling to `ml/`, not inside it):
+
+```
+<text2speech-package>/
+├── pyproject.toml          # Metadata, dependencies, console_scripts entry point
+├── README.md               # Comprehensive user documentation (§8)
+├── LICENSE                 # MIT (or Apache 2.0 to match Kokoro)
+├── src/
+│   └── <package_name>/
+│       ├── __init__.py     # Public API exports
+│       ├── cli.py          # argparse/typer CLI
+│       ├── reader.py       # File reading, Markdown → plain text
+│       ├── normalize.py    # Text normalization (numbers, abbreviations)
+│       ├── engine.py       # Kokoro TTS wrapper
+│       ├── synthesize.py   # Long-text chunking & orchestration
+│       ├── audio.py        # Post-processing, resampling, format export
+│       └── __main__.py     # python -m <package_name> support
+├── tests/
+│   ├── test_reader.py
+│   ├── test_normalize.py
+│   ├── test_audio.py
+│   └── fixtures/
+│       ├── sample.txt
+│       └── sample.md
+└── .python-version         # 3.11 or 3.12
+```
+
+Use **`hatchling`** or **`uv`** as the build backend (match modern Python packaging). Pin `requires-python = ">=3.11,<3.13"` (Kokoro/torch compatibility).
+
+### 2.2 Core Dependencies
+
+| Package | Purpose |
+|---------|---------|
+| `kokoro` | TTS engine (wraps Kokoro-82M) |
+| `torch` | Kokoro runtime |
+| `numpy` | Audio arrays |
+| `scipy` | Resampling (polyphase) |
+| `soundfile` | WAV I/O |
+| `pydub` | MP3/OGG/FLAC encoding |
+| `inflect` | Number/word normalization |
+| `tqdm` | Optional progress for long documents |
+
+**System dependency:** `ffmpeg` must be on `PATH` for MP3 export. Document install commands for macOS (`brew install ffmpeg`), Ubuntu (`apt install ffmpeg`), and Windows (`winget`/`choco`).
+
+Do **not** add DriveSpeak, `drivespeak_ml`, or Firebase as dependencies.
+
+### 2.3 Console Script Entry Point
+
+In `pyproject.toml`:
+
+```toml
+[project.scripts]
+md2speech = "<package_name>.cli:main"
+```
+
+(Replace `md2speech` and `<package_name>` with your chosen names.)
+
+---
+
+## 3. Reference Architecture (from DriveSpeak — guidance only)
+
+DriveSpeak's free TTS pipeline uses these parameters. Replicate the **behavior**, not the code:
+
+### 3.1 TTS Model & Engine
+
+| Setting | Value |
+|---------|-------|
+| Model | `hexgrad/Kokoro-82M` on Hugging Face |
+| Python API | `from kokoro import KPipeline` |
+| Language code | `"a"` (American English) |
+| Native sample rate | 24,000 Hz |
+| Inference | Local CPU or GPU via PyTorch |
+
+**Engine wrapper pattern:**
+
+```python
+pipeline = KPipeline(lang_code="a", repo_id="hexgrad/Kokoro-82M", device=None)
+for result in pipeline(text, voice=voice_id, speed=speed):
+  # collect result.audio tensors → concatenate → float32 numpy array
+```
+
+### 3.2 Recommended Voices
+
+Document these in the README:
+
+| Voice ID | Gender | Character |
+|----------|--------|-----------|
+| `af_heart` | Female | Warm, clear — **default** |
+| `am_adam` | Male | Deep, steady |
+| `af_bella` | Female | Soft |
+| `am_michael` | Male | Conversational |
+
+Full list: 11 female (`af_*`) and 9 male (`am_*`) — see Kokoro docs.
+
+### 3.3 Long-Text Synthesis Strategy
+
+For documents with multiple paragraphs, **do not** send the entire file as one Kokoro call. Instead:
+
+1. Split text on `\n\n` into paragraphs.
+2. Within each paragraph, split on `\n` into lines.
+3. Synthesize each line separately.
+4. Insert **400 ms silence** between paragraphs (configurable via `--paragraph-pause`).
+5. Concatenate all audio into one output file.
+
+Apply text normalization before each synthesis call.
+
+### 3.4 Text Normalization
+
+Before TTS, expand:
+
+- Abbreviations (`Dr.` → `Doctor`, `Mr.` → `Mister`, etc.)
+- Ordinals (`1st` → `first`)
+- Currency (`$12.50` → `twelve dollars and fifty cents`)
+- Percentages (`85%` → `eighty-five percent`)
+- Times (`3:45 PM` → spoken form)
+- Plain numbers → words
+
+Use the `inflect` library. This dramatically improves speech quality for non-fiction text.
+
+### 3.5 Audio Post-Processing
+
+Apply this chain before format export:
+
+| Step | Parameter |
+|------|-----------|
+| Peak normalization | **-1.5 dBFS** |
+| Silence padding | **100 ms** before and after the final concatenated audio |
+| Resampling | 24 kHz → **44,100 Hz** (scipy `resample_poly`) |
+| Export | User-selected format |
+
+DriveSpeak targets `.caf` (AAC) for iOS; this package targets **MP3 by default** instead.
+
+---
+
+## 4. Phase-by-Phase Implementation
+
+### Phase 1 — Project Scaffold & Packaging
+
+**Tasks:**
+
+1. Create the package directory structure (§2.1).
+2. Write `pyproject.toml` with name, version `0.1.0`, description, authors, license, Python bound, dependencies, and console script.
+3. Add `src/<package_name>/__init__.py` with version string.
+4. Verify `pip install -e .` or `uv sync && uv pip install -e .` succeeds.
+
+**Acceptance criteria:**
+
+- [ ] `pip install -e .` completes without error
+- [ ] `md2speech --help` prints usage
+- [ ] Package imports: `python -c "import <package_name>"`
+
+---
+
+### Phase 2 — Text Ingestion
+
+**Tasks:**
+
+1. Implement `read_document(path: Path) -> str` in `reader.py`.
+2. Support `.txt`, `.md`, `.markdown`.
+3. Implement Markdown → plain text extraction (§1.4).
+4. Add unit tests with fixture files (short `.txt` and `.md` with headings, links, code blocks, front matter).
+
+**Acceptance criteria:**
+
+- [ ] `# Title\n\nHello **world**` → speakable text without markup
+- [ ] Front matter stripped
+- [ ] Fenced code blocks handled consistently (documented behavior)
+- [ ] Tests pass
+
+---
+
+### Phase 3 — TTS Engine & Long-Text Synthesis
+
+**Tasks:**
+
+1. Implement `engine.py` — thin `TTSEngine` class wrapping `KPipeline`.
+2. Implement `normalize.py` — text normalization (§3.4).
+3. Implement `synthesize.py`:
+   - `synthesize_text(text, voice, speed) -> np.ndarray` for short strings
+   - `synthesize_long_text(text, voice, speed, paragraph_pause) -> np.ndarray` with chunking (§3.3)
+4. Lazy-load the pipeline (instantiate on first use, not import).
+5. Log model download progress on first run.
+
+**Acceptance criteria:**
+
+- [ ] Short string synthesizes to 24 kHz float32 numpy array
+- [ ] Multi-paragraph input produces audio with audible pauses between paragraphs
+- [ ] Normalization expands `Dr. Smith paid $5` correctly
+- [ ] Voice and speed parameters work
+
+---
+
+### Phase 4 — Audio Post-Processing & Format Conversion
+
+**Tasks:**
+
+1. Implement `audio.py`:
+   - `peak_normalize(audio, target_dbfs=-1.5)`
+   - `add_silence_padding(audio, sample_rate, pad_ms=100)`
+   - `resample(audio, orig_sr, target_sr=44100)`
+   - `write_audio(audio, path, format, sample_rate=44100)` — dispatches to soundfile (WAV) or pydub (MP3/OGG/FLAC)
+2. Implement ffmpeg presence check with actionable error:
+   ```
+   Error: ffmpeg not found. MP3 export requires ffmpeg.
+   Install: brew install ffmpeg  (macOS)
+   ```
+3. Return metadata (duration, output path) from write function.
+
+**Acceptance criteria:**
+
+- [ ] WAV export works without ffmpeg
+- [ ] MP3 export produces playable file when ffmpeg is installed
+- [ ] Peak level is consistent across outputs
+- [ ] Output sample rate is 44,100 Hz
+
+---
+
+### Phase 5 — CLI & Public API
+
+**Tasks:**
+
+1. Wire `cli.py` with `argparse` (or `typer` if you prefer).
+2. Implement `synthesize_file()` in `__init__.py` or `synthesize.py`.
+3. Add `python -m <package_name>` entry via `__main__.py`.
+4. Add `--verbose` logging (show paragraph count, synthesis progress, output path, duration).
+5. Handle errors gracefully: missing input file, unsupported format, missing ffmpeg, empty document.
+
+**Acceptance criteria:**
+
+- [ ] `md2speech sample.md` creates `sample.mp3` next to input
+- [ ] `md2speech sample.txt -o /tmp/out.wav --format wav` works
+- [ ] `--help` documents all options
+- [ ] Exit code 0 on success, non-zero on failure
+- [ ] Library API works from Python REPL
+
+---
+
+### Phase 6 — Tests, Documentation & Install Verification
+
+**Tasks:**
+
+1. Write tests (§2.1). Mock Kokoro in unit tests to avoid downloading the model in CI; optionally mark one integration test `@pytest.mark.integration` that runs real synthesis.
+2. Write comprehensive `README.md` (§8).
+3. Add a `LICENSE` file.
+4. Run full install on a clean virtualenv and convert a sample file end-to-end.
+
+**Acceptance criteria:**
+
+- [ ] `pytest` passes (unit tests; integration test optional/skipped in CI)
+- [ ] README covers all sections in §8
+- [ ] Fresh `pip install .` → `md2speech` works on a sample file
+- [ ] No references to DriveSpeak in code or user-facing docs (optional brief credit in README acknowledgments is fine)
+
+---
+
+## 5. Error Handling & Edge Cases
+
+| Scenario | Behavior |
+|----------|----------|
+| Input file not found | Clear error, exit 1 |
+| Empty file after extraction | Clear error, exit 1 |
+| Unsupported extension | Clear error listing supported types |
+| ffmpeg missing for MP3 | Actionable install instructions |
+| Very long document (100+ paragraphs) | Show tqdm progress, do not load entire audio in duplicate |
+| GPU available | Pass `device="cuda"` or `device="mps"` if torch detects it; default CPU |
+| Model download fails (no network) | Clear error mentioning Hugging Face access |
+
+---
+
+## 6. Non-Goals (Do Not Implement)
+
+- Real-time / streaming playback
+- SSML or phoneme-level control
+- Voice cloning or custom voice training
+- Paid TTS APIs (ElevenLabs, OpenAI, Google Cloud TTS)
+- Web UI or REST server (CLI + library only)
+- DriveSpeak `.caf` output (iOS-specific; MP3/WAV is sufficient)
+- PDF or DOCX input (text/Markdown only for v0.1)
+
+---
+
+## 7. Quality Bar
+
+- **Type hints** on all public functions
+- **`logging`** module (not bare `print`) for operational messages; `print` only for CLI output if desired
+- **No over-engineering** — a focused v0.1 beats a framework
+- **Consistent naming** — pick `md2speech` or `text2speech` as the CLI name and stick with it
+- **Pinned or bounded dependencies** in `pyproject.toml` for reproducible installs
+
+---
+
+## 8. README Documentation Requirements
+
+The `README.md` must include all of the following sections:
+
+1. **Overview** — What the tool does in 2–3 sentences
+2. **Features** — Bullet list (free, offline, Markdown support, MP3 default, etc.)
+3. **Requirements** — Python version, ffmpeg (for MP3), disk space for model (~hundreds of MB)
+4. **Installation**
+   - `pip install .` from source
+   - `uv sync` alternative
+   - ffmpeg install per platform
+   - Note that first run downloads Kokoro-82M from Hugging Face
+5. **Quick Start** — Copy-paste examples (at least 3)
+6. **CLI Reference** — Table of all arguments
+7. **Python API** — `synthesize_file()` example and advanced imports
+8. **Voice Reference** — Table of recommended Kokoro voice IDs
+9. **Supported Formats** — mp3, wav, etc. and which need ffmpeg
+10. **How It Works** — Brief pipeline diagram or numbered steps (read → normalize → chunk → synthesize → post-process → encode)
+11. **Markdown Handling** — What markup is stripped, how code blocks are treated
+12. **Troubleshooting** — ffmpeg not found, model download, torch/MPS/CUDA, memory
+13. **License** — MIT/Apache
+14. **Acknowledgments** — Kokoro-82M (hexgrad), Hugging Face
+
+---
+
+## 9. Suggested Package Names
+
+Pick one during implementation (check PyPI availability if publishing):
+
+| Name | CLI command |
+|------|-------------|
+| `md2speech` | `md2speech` |
+| `text2speech` | `text2speech` |
+| `kokoro-read` | `kokoro-read` |
+| `speakmd` | `speakmd` |
+
+---
+
+## 10. Final Deliverables Checklist
+
+Before marking the task complete, confirm:
+
+- [ ] Standalone package directory with `pyproject.toml`
+- [ ] `pip install .` installs all Python dependencies
+- [ ] CLI: `md2speech <input.md> [-o path] [--format mp3]`
+- [ ] Default output: same basename as input, `.mp3` extension, same directory
+- [ ] Markdown and plain text supported
+- [ ] Kokoro-82M local TTS (free, no API key)
+- [ ] MP3 export via pydub/ffmpeg; WAV via soundfile
+- [ ] Long-text paragraph chunking with pauses
+- [ ] Text normalization (numbers, abbreviations)
+- [ ] Audio post-processing (normalize, pad, resample to 44.1 kHz)
+- [ ] Comprehensive `README.md`
+- [ ] Unit tests with mocked TTS
+- [ ] No DriveSpeak code dependencies
+
+---
+
+## 11. Smoke Test Script
+
+After implementation, this sequence must succeed on macOS/Linux:
+
+```bash
+cd <package-directory>
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"   # or: uv sync
+
+# Verify ffmpeg for MP3
+ffmpeg -version
+
+# Create a test file
+cat > /tmp/test_doc.md << 'EOF'
+---
+title: Test
+---
+
+# Introduction
+
+Dr. Smith ordered 3 cups of coffee at 9:15 AM.
+
+## Details
+
+The total was **$12.50**. Visit [our site](https://example.com) for more.
+EOF
+
+# Convert
+md2speech /tmp/test_doc.md -o /tmp/test_doc.mp3 --verbose
+
+# Verify output exists and is non-trivial size
+test -f /tmp/test_doc.mp3
+test $(stat -f%z /tmp/test_doc.mp3 2>/dev/null || stat -c%s /tmp/test_doc.mp3) -gt 1000
+echo "Smoke test passed"
+```
+
+---
+
+*End of agent prompt.*