stream-replace 0.1.0__tar.gz

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

@@ -0,0 +1,21 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[dev]" pytest pytest-asyncio
+      - run: pytest

stream_replace-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

stream_replace-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

stream_replace-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

stream_replace-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: stream-replace
+Version: 0.1.0
+Summary: Streaming text replacement for AI token streams — handles partial matches across chunk boundaries
+License-Expression: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Filters
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# stream-replace
+
+Streaming text replacement for AI token streams — correctly handles partial matches across chunk boundaries.
+
+## Install
+
+```bash
+pip install stream-replace
+```
+
+## Quick Start
+
+```python
+import re
+from stream_replace import Replacer
+
+r = Replacer([
+    ("敏感词", "***"),                                        # string → string
+    ("secret", lambda s: s[0] + "***"),                       # string → callable
+    (re.compile(r"1[3-9]\d{9}"), "[PHONE]"),                  # regex  → string
+    (re.compile(r"<think>[\s\S]*?</think>"), ""),              # regex  → remove
+    (re.compile(r"(\d+)"), lambda m: str(int(m.group()) * 2)), # regex  → callable
+])
+
+for chunk in ai_stream:
+    safe_text = r.feed(chunk)
+    print(safe_text, end="")
+
+print(r.flush(), end="")
+```
+
+## Why?
+
+AI models stream tokens incrementally. A word you want to replace may be split across chunks:
+
+```
+chunk 1: "hel"
+chunk 2: "lo world"
+```
+
+Naive per-chunk replacement would miss `"hello"`. **stream-replace** buffers just enough text at chunk boundaries to detect partial matches, while emitting safe text as early as possible.
+
+## API
+
+### `Replacer(rules)`
+
+Create a replacer with a list of `(pattern, replacement)` tuples.
+
+| Pattern | Replacement | Description |
+|---|---|---|
+| `str` | `str` | Exact string replacement |
+| `str` | `callable(matched_str) → str` | Dynamic string replacement |
+| `re.Pattern` | `str` | Regex replacement (supports `\1` backrefs) |
+| `re.Pattern` | `callable(re.Match) → str` | Dynamic regex replacement |
+
+#### `r.feed(chunk: str) → str`
+
+Process one incoming chunk. Returns text that is safe to emit (fully resolved, no pending partial matches).
+
+#### `r.flush() → str`
+
+Flush the internal buffer after the stream ends. Must be called once to get any remaining text.
+
+#### `r.reset()`
+
+Clear internal state so the replacer can be reused for another stream.
+
+#### `r.wrap(iterable) → Iterable[str]`
+
+Convenience wrapper for a sync chunk stream. Handles `feed` + `flush` automatically.
+
+```python
+for text in r.wrap(chunks):
+    print(text, end="")
+```
+
+#### `r.wrap_async(async_iterable) → AsyncIterable[str]`
+
+Same as `wrap`, but for async iterables.
+
+```python
+async for text in r.wrap_async(async_chunks):
+    print(text, end="")
+```
+
+### Functional API
+
+For one-off use without creating a `Replacer` instance:
+
+```python
+from stream_replace import stream_replace, astream_replace
+
+# sync
+for text in stream_replace(chunks, [("hello", "world")]):
+    print(text, end="")
+
+# async
+async for text in astream_replace(async_chunks, [("hello", "world")]):
+    print(text, end="")
+```
+
+## How It Works
+
+1. **Buffer**: Incoming chunks accumulate in an internal buffer.
+2. **Match**: On each `feed()`, the buffer is scanned for complete matches across all rules. The earliest match wins.
+3. **Replace**: Matched text is replaced; scanning continues from after the replacement.
+4. **Hold back**: After all matches, the buffer tail is checked for *potential* partial matches (a suffix that could be the start of a pattern). This tail is held back for the next `feed()`.
+5. **Flush**: On `flush()`, the remaining buffer is processed without holding anything back.
+
+For regex rules, the library automatically extracts literal prefixes from the pattern (e.g., `"<think>"` from `r"<think>[\s\S]*?</think>"`) to detect both partial prefix matches and open-but-unclosed matches spanning multiple chunks.
+
+## License
+
+MIT

stream_replace-0.1.0/README.md

@@ -0,0 +1,114 @@
+# stream-replace
+
+Streaming text replacement for AI token streams — correctly handles partial matches across chunk boundaries.
+
+## Install
+
+```bash
+pip install stream-replace
+```
+
+## Quick Start
+
+```python
+import re
+from stream_replace import Replacer
+
+r = Replacer([
+    ("敏感词", "***"),                                        # string → string
+    ("secret", lambda s: s[0] + "***"),                       # string → callable
+    (re.compile(r"1[3-9]\d{9}"), "[PHONE]"),                  # regex  → string
+    (re.compile(r"<think>[\s\S]*?</think>"), ""),              # regex  → remove
+    (re.compile(r"(\d+)"), lambda m: str(int(m.group()) * 2)), # regex  → callable
+])
+
+for chunk in ai_stream:
+    safe_text = r.feed(chunk)
+    print(safe_text, end="")
+
+print(r.flush(), end="")
+```
+
+## Why?
+
+AI models stream tokens incrementally. A word you want to replace may be split across chunks:
+
+```
+chunk 1: "hel"
+chunk 2: "lo world"
+```
+
+Naive per-chunk replacement would miss `"hello"`. **stream-replace** buffers just enough text at chunk boundaries to detect partial matches, while emitting safe text as early as possible.
+
+## API
+
+### `Replacer(rules)`
+
+Create a replacer with a list of `(pattern, replacement)` tuples.
+
+| Pattern | Replacement | Description |
+|---|---|---|
+| `str` | `str` | Exact string replacement |
+| `str` | `callable(matched_str) → str` | Dynamic string replacement |
+| `re.Pattern` | `str` | Regex replacement (supports `\1` backrefs) |
+| `re.Pattern` | `callable(re.Match) → str` | Dynamic regex replacement |
+
+#### `r.feed(chunk: str) → str`
+
+Process one incoming chunk. Returns text that is safe to emit (fully resolved, no pending partial matches).
+
+#### `r.flush() → str`
+
+Flush the internal buffer after the stream ends. Must be called once to get any remaining text.
+
+#### `r.reset()`
+
+Clear internal state so the replacer can be reused for another stream.
+
+#### `r.wrap(iterable) → Iterable[str]`
+
+Convenience wrapper for a sync chunk stream. Handles `feed` + `flush` automatically.
+
+```python
+for text in r.wrap(chunks):
+    print(text, end="")
+```
+
+#### `r.wrap_async(async_iterable) → AsyncIterable[str]`
+
+Same as `wrap`, but for async iterables.
+
+```python
+async for text in r.wrap_async(async_chunks):
+    print(text, end="")
+```
+
+### Functional API
+
+For one-off use without creating a `Replacer` instance:
+
+```python
+from stream_replace import stream_replace, astream_replace
+
+# sync
+for text in stream_replace(chunks, [("hello", "world")]):
+    print(text, end="")
+
+# async
+async for text in astream_replace(async_chunks, [("hello", "world")]):
+    print(text, end="")
+```
+
+## How It Works
+
+1. **Buffer**: Incoming chunks accumulate in an internal buffer.
+2. **Match**: On each `feed()`, the buffer is scanned for complete matches across all rules. The earliest match wins.
+3. **Replace**: Matched text is replaced; scanning continues from after the replacement.
+4. **Hold back**: After all matches, the buffer tail is checked for *potential* partial matches (a suffix that could be the start of a pattern). This tail is held back for the next `feed()`.
+5. **Flush**: On `flush()`, the remaining buffer is processed without holding anything back.
+
+For regex rules, the library automatically extracts literal prefixes from the pattern (e.g., `"<think>"` from `r"<think>[\s\S]*?</think>"`) to detect both partial prefix matches and open-but-unclosed matches spanning multiple chunks.
+
+## License
+
+MIT

stream_replace-0.1.0/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from stream-replace!")
+
+
+if __name__ == "__main__":
+    main()

stream_replace-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "stream-replace"
+version = "0.1.0"
+description = "Streaming text replacement for AI token streams — handles partial matches across chunk boundaries"
+readme = "README.md"
+requires-python = ">=3.13"
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Text Processing :: Filters",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

stream_replace-0.1.0/stream_replace/__init__.py

@@ -0,0 +1,4 @@
+from stream_replace._replacer import Replacer
+from stream_replace._functional import stream_replace, astream_replace
+
+__all__ = ["Replacer", "stream_replace", "astream_replace"]

stream_replace-0.1.0/stream_replace/_functional.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import AsyncIterable, Iterable
+
+from stream_replace._replacer import Replacer
+
+
+def stream_replace(
+    iterable: Iterable[str],
+    rules: list[tuple],
+) -> Iterable[str]:
+    """Convenience wrapper — apply replacement *rules* to a sync chunk stream."""
+    return Replacer(rules).wrap(iterable)
+
+
+async def astream_replace(
+    iterable: AsyncIterable[str],
+    rules: list[tuple],
+) -> AsyncIterable[str]:
+    """Convenience wrapper — apply replacement *rules* to an async chunk stream."""
+    async for chunk in Replacer(rules).wrap_async(iterable):
+        yield chunk

stream_replace-0.1.0/stream_replace/_replacer.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from typing import AsyncIterable, Iterable
+
+from stream_replace._rule import Rule, parse_rule
+
+
+class Replacer:
+    """Streaming text replacer that correctly handles partial matches across
+    chunk boundaries.
+
+    Usage::
+
+        r = Replacer([("hello", "world")])
+        for chunk in token_stream:
+            yield r.feed(chunk)
+        yield r.flush()
+    """
+
+    __slots__ = ("_rules", "_buffer")
+
+    def __init__(self, rules: list[tuple]) -> None:
+        self._rules: list[Rule] = [parse_rule(r) for r in rules]
+        self._buffer: str = ""
+
+    # ------------------------------------------------------------------
+    # Core API
+    # ------------------------------------------------------------------
+
+    def feed(self, chunk: str) -> str:
+        """Process an incoming chunk.  Returns text that is safe to emit."""
+        if not chunk:
+            return ""
+        self._buffer += chunk
+        return self._process(flushing=False)
+
+    def flush(self) -> str:
+        """Flush any remaining buffered text.  Call once after the stream ends."""
+        return self._process(flushing=True)
+
+    def reset(self) -> None:
+        """Clear internal state so the instance can be reused."""
+        self._buffer = ""
+
+    # ------------------------------------------------------------------
+    # Convenience wrappers
+    # ------------------------------------------------------------------
+
+    def wrap(self, iterable: Iterable[str]) -> Iterable[str]:
+        """Wrap a sync iterable of chunks, yielding replaced text."""
+        self.reset()
+        for chunk in iterable:
+            out = self.feed(chunk)
+            if out:
+                yield out
+        out = self.flush()
+        if out:
+            yield out
+
+    async def wrap_async(self, iterable: AsyncIterable[str]) -> AsyncIterable[str]:
+        """Wrap an async iterable of chunks, yielding replaced text."""
+        self.reset()
+        async for chunk in iterable:
+            out = self.feed(chunk)
+            if out:
+                yield out
+        out = self.flush()
+        if out:
+            yield out
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _process(self, *, flushing: bool) -> str:
+        result: list[str] = []
+        buf = self._buffer
+
+        # Phase 1: find and apply all complete matches iteratively
+        pos = 0
+        while pos < len(buf):
+            earliest = self._find_earliest_match(buf, pos)
+            if earliest is None:
+                break
+            result.append(buf[pos:earliest.start])
+            result.append(earliest.replacement_text)
+            pos = earliest.end
+
+        remaining = buf[pos:]
+
+        if flushing:
+            # No more data coming — do one final replacement pass on the
+            # remaining tail, then emit everything.
+            final = self._replace_all(remaining)
+            result.append(final)
+            self._buffer = ""
+        else:
+            # Determine safe-to-emit boundary in *remaining*.
+            safe = self._safe_boundary(remaining)
+            result.append(remaining[:safe])
+            self._buffer = remaining[safe:]
+
+        return "".join(result)
+
+    def _find_earliest_match(self, text: str, pos: int):
+        """Return the earliest MatchResult among all rules, or None."""
+        from stream_replace._rule import MatchResult
+
+        best: MatchResult | None = None
+        for rule in self._rules:
+            m = rule.search(text, pos)
+            if m is not None and (best is None or m.start < best.start):
+                best = m
+        return best
+
+    def _safe_boundary(self, remaining: str) -> int:
+        """How many characters from *remaining* can be safely emitted."""
+        if not remaining:
+            return 0
+
+        safe = len(remaining)
+        for rule in self._rules:
+            p = rule.find_partial_start(remaining)
+            if p is not None and p < safe:
+                safe = p
+        return safe
+
+    def _replace_all(self, text: str) -> str:
+        """Run all rules on *text* until no more matches (for flush)."""
+        buf = text
+        changed = True
+        while changed:
+            changed = False
+            pos = 0
+            parts: list[str] = []
+            while pos < len(buf):
+                m = self._find_earliest_match(buf, pos)
+                if m is None:
+                    break
+                parts.append(buf[pos:m.start])
+                parts.append(m.replacement_text)
+                pos = m.end
+                changed = True
+            parts.append(buf[pos:])
+            buf = "".join(parts)
+        return buf

stream_replace-0.1.0/stream_replace/_rule.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Callable, Union
+
+from stream_replace._utils import extract_literal_prefix, find_suffix_prefix_overlap
+
+Replacement = Union[str, Callable]
+
+
+@dataclass(slots=True)
+class MatchResult:
+    start: int
+    end: int
+    replacement_text: str
+
+
+@dataclass(slots=True)
+class StringRule:
+    pattern: str
+    replacement: Replacement
+
+    def search(self, text: str, pos: int = 0) -> MatchResult | None:
+        idx = text.find(self.pattern, pos)
+        if idx == -1:
+            return None
+        matched = self.pattern
+        rep = self.replacement(matched) if callable(self.replacement) else self.replacement
+        return MatchResult(start=idx, end=idx + len(self.pattern), replacement_text=rep)
+
+    def find_partial_start(self, text: str) -> int | None:
+        return find_suffix_prefix_overlap(text, self.pattern)
+
+
+@dataclass(slots=True)
+class RegexRule:
+    regex: re.Pattern[str]
+    replacement: Replacement
+    literal_prefix: str = field(init=False)
+    _fallback_lookback: int = 0
+
+    def __post_init__(self) -> None:
+        self.literal_prefix = extract_literal_prefix(self.regex)
+        if not self.literal_prefix and self._fallback_lookback == 0:
+            self._fallback_lookback = 32
+
+    def search(self, text: str, pos: int = 0) -> MatchResult | None:
+        m = self.regex.search(text, pos)
+        if m is None:
+            return None
+        if callable(self.replacement):
+            rep = self.replacement(m)
+        else:
+            rep = m.expand(self.replacement)
+        return MatchResult(start=m.start(), end=m.end(), replacement_text=rep)
+
+    def find_partial_start(self, text: str) -> int | None:
+        prefix = self.literal_prefix
+        if prefix:
+            # Check whether a complete literal prefix exists without a full
+            # regex match — that means an open (unfinished) match is in
+            # progress and we must hold back from that position.
+            search_start = 0
+            while True:
+                idx = text.find(prefix, search_start)
+                if idx == -1:
+                    break
+                if self.regex.search(text, idx) is None:
+                    return idx
+                search_start = idx + 1
+
+            # Also check if the very tail is a *partial* literal prefix
+            # (token split mid-prefix).
+            return find_suffix_prefix_overlap(text, prefix)
+
+        if self._fallback_lookback > 0 and len(text) > 0:
+            return max(0, len(text) - self._fallback_lookback)
+        return None
+
+
+Rule = StringRule | RegexRule
+
+
+def parse_rule(spec: tuple) -> Rule:
+    """Convert a user-supplied tuple into a Rule object.
+
+    Accepted forms:
+        (str,   str | callable)
+        (re.Pattern, str | callable)
+        (str,   str | callable, dict)      -- extra options forwarded
+        (re.Pattern, str | callable, dict)
+    """
+    if len(spec) == 2:
+        pattern, replacement = spec
+        opts: dict = {}
+    elif len(spec) == 3:
+        pattern, replacement, opts = spec
+    else:
+        raise ValueError(f"Rule tuple must have 2 or 3 elements, got {len(spec)}")
+
+    if isinstance(pattern, str):
+        return StringRule(pattern=pattern, replacement=replacement)
+    if isinstance(pattern, re.Pattern):
+        lookback = opts.get("lookback", 0)
+        rule = RegexRule(regex=pattern, replacement=replacement, _fallback_lookback=lookback)
+        return rule
+
+    raise TypeError(f"Pattern must be str or re.Pattern, got {type(pattern).__name__}")

stream_replace-0.1.0/stream_replace/_utils.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import re
+
+try:
+    import re._parser as _sre_parse  # Python 3.13+
+except ImportError:
+    import sre_parse as _sre_parse  # type: ignore[no-redef]
+
+
+def extract_literal_prefix(pattern: re.Pattern[str]) -> str:
+    """Extract the leading literal character sequence from a compiled regex.
+
+    Examples:
+        r"<think>[\\s\\S]*?</think>" -> "<think>"
+        r"hello\\s+world"            -> "hello"
+        r"\\d{11}"                   -> ""
+    """
+    try:
+        parsed = _sre_parse.parse(pattern.pattern)
+    except Exception:
+        return ""
+
+    chars: list[str] = []
+    for op, av in parsed:
+        if op == _sre_parse.LITERAL:
+            chars.append(chr(av))
+        else:
+            break
+    return "".join(chars)
+
+
+def find_suffix_prefix_overlap(text: str, pattern: str) -> int | None:
+    """Find the earliest position in *text* where a suffix of *text* equals
+    a proper prefix of *pattern*.
+
+    Returns the start index in *text*, or None if no overlap exists.
+
+    Example:
+        text="abc hel", pattern="hello" -> 4  (suffix "hel" is prefix of "hello")
+    """
+    if not pattern:
+        return None
+
+    max_check = min(len(text), len(pattern) - 1)
+    for length in range(max_check, 0, -1):
+        suffix = text[-length:]
+        if pattern[:length] == suffix:
+            return len(text) - length
+    return None

stream_replace-0.1.0/tests/test_stream_replace.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from stream_replace import Replacer, astream_replace, stream_replace
+
+
+# ---------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------
+
+def collect(replacer: Replacer, chunks: list[str]) -> str:
+    parts = [replacer.feed(c) for c in chunks]
+    parts.append(replacer.flush())
+    return "".join(parts)
+
+
+async def _async_gen(chunks: list[str]):
+    for c in chunks:
+        yield c
+
+
+# ---------------------------------------------------------------
+# Basic string replacement
+# ---------------------------------------------------------------
+
+class TestStringBasic:
+    def test_single_chunk(self):
+        r = Replacer([("hello", "world")])
+        assert collect(r, ["hello there"]) == "world there"
+
+    def test_multiple_occurrences(self):
+        r = Replacer([("ab", "X")])
+        assert collect(r, ["ab cd ab"]) == "X cd X"
+
+    def test_no_match(self):
+        r = Replacer([("xyz", "!")])
+        assert collect(r, ["hello world"]) == "hello world"
+
+    def test_empty_chunks(self):
+        r = Replacer([("a", "b")])
+        assert collect(r, ["", "a", "", "a", ""]) == "bb"
+
+    def test_replacement_with_callable(self):
+        r = Replacer([("bad", lambda s: s.upper())])
+        assert collect(r, ["this is bad"]) == "this is BAD"
+
+
+# ---------------------------------------------------------------
+# Cross-chunk partial matching (strings)
+# ---------------------------------------------------------------
+
+class TestStringPartial:
+    def test_split_across_two_chunks(self):
+        r = Replacer([("hello", "world")])
+        assert collect(r, ["hel", "lo"]) == "world"
+
+    def test_split_across_three_chunks(self):
+        r = Replacer([("hello", "world")])
+        assert collect(r, ["he", "ll", "o done"]) == "world done"
+
+    def test_partial_that_never_completes(self):
+        r = Replacer([("hello", "world")])
+        assert collect(r, ["hel", " nope"]) == "hel nope"
+
+    def test_overlapping_partial(self):
+        r = Replacer([("abc", "X")])
+        assert collect(r, ["ab", "ab", "c"]) == "abX"
+
+    def test_partial_at_stream_end(self):
+        r = Replacer([("hello", "world")])
+        assert collect(r, ["hel"]) == "hel"
+
+    def test_match_then_partial(self):
+        r = Replacer([("aa", "X")])
+        assert collect(r, ["aa", "a"]) == "Xa"
+
+
+# ---------------------------------------------------------------
+# Regex replacement
+# ---------------------------------------------------------------
+
+class TestRegex:
+    def test_simple_regex(self):
+        r = Replacer([(re.compile(r"\d+"), "#")])
+        assert collect(r, ["abc 123 def"]) == "abc # def"
+
+    def test_phone_number_masking(self):
+        r = Replacer([(re.compile(r"1[3-9]\d{9}"), "[PHONE]")])
+        assert collect(r, ["call 13800138000 now"]) == "call [PHONE] now"
+
+    def test_regex_with_groups(self):
+        r = Replacer([(re.compile(r"(\d+)"), lambda m: str(int(m.group()) * 2))])
+        assert collect(r, ["val=5 x=10"]) == "val=10 x=20"
+
+    def test_regex_expand(self):
+        r = Replacer([(re.compile(r"(\w+)@(\w+)"), r"\1[at]\2")])
+        assert collect(r, ["email: a@b"]) == "email: a[at]b"
+
+
+# ---------------------------------------------------------------
+# Tag-style removal (unbounded regex)
+# ---------------------------------------------------------------
+
+class TestTagRemoval:
+    def test_think_tag_single_chunk(self):
+        r = Replacer([(re.compile(r"<think>[\s\S]*?</think>"), "")])
+        assert collect(r, ["<think>reasoning</think>answer"]) == "answer"
+
+    def test_think_tag_across_chunks(self):
+        r = Replacer([(re.compile(r"<think>[\s\S]*?</think>"), "")])
+        chunks = ["<think>", "some reasoning", "</think>", "final answer"]
+        assert collect(r, chunks) == "final answer"
+
+    def test_think_tag_split_open(self):
+        r = Replacer([(re.compile(r"<think>[\s\S]*?</think>"), "")])
+        chunks = ["<thi", "nk>stuff</think>ok"]
+        assert collect(r, chunks) == "ok"
+
+    def test_think_tag_split_close(self):
+        r = Replacer([(re.compile(r"<think>[\s\S]*?</think>"), "")])
+        chunks = ["<think>stuff</thi", "nk>ok"]
+        assert collect(r, chunks) == "ok"
+
+    def test_text_before_think_tag(self):
+        r = Replacer([(re.compile(r"<think>[\s\S]*?</think>"), "")])
+        chunks = ["prefix <think>", "inner", "</think> suffix"]
+        assert collect(r, chunks) == "prefix  suffix"
+
+
+# ---------------------------------------------------------------
+# Multiple rules
+# ---------------------------------------------------------------
+
+class TestMultipleRules:
+    def test_string_and_regex(self):
+        r = Replacer([
+            ("foo", "bar"),
+            (re.compile(r"\d+"), "#"),
+        ])
+        assert collect(r, ["foo has 3 items"]) == "bar has # items"
+
+    def test_earliest_match_wins(self):
+        r = Replacer([
+            ("bc", "X"),
+            ("ab", "Y"),
+        ])
+        assert collect(r, ["abc"]) == "Yc"
+
+    def test_non_overlapping(self):
+        r = Replacer([
+            ("aa", "X"),
+            ("bb", "Y"),
+        ])
+        assert collect(r, ["aabb"]) == "XY"
+
+
+# ---------------------------------------------------------------
+# wrap / wrap_async
+# ---------------------------------------------------------------
+
+class TestWrap:
+    def test_wrap_sync(self):
+        r = Replacer([("hello", "world")])
+        result = "".join(r.wrap(["hel", "lo there"]))
+        assert result == "world there"
+
+    def test_wrap_sync_functional(self):
+        result = "".join(stream_replace(["hel", "lo"], [("hello", "world")]))
+        assert result == "world"
+
+    @pytest.mark.asyncio
+    async def test_wrap_async(self):
+        r = Replacer([("hello", "world")])
+        parts = []
+        async for chunk in r.wrap_async(_async_gen(["hel", "lo there"])):
+            parts.append(chunk)
+        assert "".join(parts) == "world there"
+
+    @pytest.mark.asyncio
+    async def test_astream_replace(self):
+        parts = []
+        async for chunk in astream_replace(
+            _async_gen(["hel", "lo"]),
+            [("hello", "world")],
+        ):
+            parts.append(chunk)
+        assert "".join(parts) == "world"
+
+
+# ---------------------------------------------------------------
+# Reset / reuse
+# ---------------------------------------------------------------
+
+class TestReset:
+    def test_reset_clears_buffer(self):
+        r = Replacer([("hello", "world")])
+        r.feed("hel")
+        r.reset()
+        assert collect(r, ["hello"]) == "world"
+
+
+# ---------------------------------------------------------------
+# Edge cases
+# ---------------------------------------------------------------
+
+class TestEdgeCases:
+    def test_empty_stream(self):
+        r = Replacer([("x", "y")])
+        assert collect(r, []) == ""
+
+    def test_replacement_longer_than_pattern(self):
+        r = Replacer([("a", "xyz")])
+        assert collect(r, ["aaa"]) == "xyzxyzxyz"
+
+    def test_replacement_empty(self):
+        r = Replacer([("remove", "")])
+        assert collect(r, ["please remove this"]) == "please  this"
+
+    def test_chinese_characters(self):
+        r = Replacer([("敏感词", "***")])
+        assert collect(r, ["这是一个敏", "感词测试"]) == "这是一个***测试"
+
+    def test_single_char_pattern(self):
+        r = Replacer([("x", "O")])
+        assert collect(r, ["axbxc"]) == "aObOc"
+
+    def test_pattern_same_as_replacement(self):
+        r = Replacer([("a", "a")])
+        assert collect(r, ["aaa"]) == "aaa"
+
+    def test_unicode_emoji(self):
+        r = Replacer([("😀", "smile")])
+        assert collect(r, ["hello 😀 world"]) == "hello smile world"
+
+    def test_many_small_chunks(self):
+        r = Replacer([("hello", "world")])
+        assert collect(r, list("hello")) == "world"