cecli-dev 1.5.0rc2__tar.gz → 1.5.0rc3__tar.gz

{cecli_dev-1.5.0rc2 → cecli_dev-1.5.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc2
+Version: 1.5.0rc3
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.5.0rc2 → cecli_dev-1.5.0rc3}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.0rc2'
-__version_tuple__ = version_tuple = (1, 5, 0, 'rc2')
+__version__ = version = '1.5.0rc3'
+__version_tuple__ = version_tuple = (1, 5, 0, 'rc3')
 
-__commit_id__ = commit_id = 'g12134c928'
+__commit_id__ = commit_id = 'g3717269c6'

{cecli_dev-1.5.0rc2 → cecli_dev-1.5.0rc3}/cecli/args.py

@@ -578,6 +578,18 @@ def get_parser(default_config_files, git_root):
         help="Number of times to ping at 5min intervals to keep prompt cache warm (default: 0)",
     )
 
+    ##########
+    group = parser.add_argument_group("Rate limiting")
+    group.add_argument(
+        "--tokens-per-minute",
+        type=int,
+        default=1000000,
+        help=(
+            "Set the maximum tokens sent per minute before rate limiting sleeps are"
+            " inserted before LLM API calls (default: 1000000, use 0 to disable)"
+        ),
+    )
+
     ##########
     group = parser.add_argument_group("Repomap settings")
     group.add_argument(

{cecli_dev-1.5.0rc2 → cecli_dev-1.5.0rc3}/cecli/coders/base_coder.py

@@ -74,6 +74,9 @@ from ..prompts.utils.registry import PromptObject, PromptRegistry
 
 GLOBAL_DATE = date.today().isoformat()
 
+# Default per-minute token budget used for rate limiting when not configured.
+DEFAULT_TOKENS_PER_MINUTE = 1000000
+
 
 class UnknownEditFormat(ValueError):
     def __init__(self, edit_format, valid_formats):
@@ -119,6 +122,8 @@ class UsageMeta(type):
     _total_tokens_sent = 0
     _total_tokens_received = 0
     _total_cached_tokens = 0
+    _token_usage_buffer = {}
+    _token_usage_window = 60.0
 
     @property
     def total_cost(cls):
@@ -152,6 +157,47 @@ class UsageMeta(type):
     def total_cached_tokens(cls, value):
         UsageMeta._total_cached_tokens = value
 
+    @classmethod
+    def _purge_token_usage(cls, model, now=None):
+        """Drop a model's token-usage entries older than the rolling window."""
+        if now is None:
+            now = time.time()
+        cutoff = now - UsageMeta._token_usage_window
+        entries = UsageMeta._token_usage_buffer.get(model, [])
+        UsageMeta._token_usage_buffer[model] = [
+            (tokens, ts) for tokens, ts in entries if ts >= cutoff
+        ]
+
+    @classmethod
+    def _record_token_usage(cls, model, delta, now=None):
+        """Record a model's request prompt-token usage as (tokens, timestamp)."""
+        if delta <= 0 or model is None:
+            return
+        if now is None:
+            now = time.time()
+        UsageMeta._token_usage_buffer.setdefault(model, []).append((delta, now))
+        UsageMeta._purge_token_usage(model, now)
+
+    @classmethod
+    def _get_token_usage_stats(cls, model, now=None):
+        """Return a model's (tokens_last_minute, max_single_request, requests_per_minute)."""
+        if now is None:
+            now = time.time()
+        UsageMeta._purge_token_usage(model, now)
+        buffer = UsageMeta._token_usage_buffer.get(model, [])
+        tokens_last_minute = sum(tokens for tokens, _ in buffer)
+        max_single_request = max((tokens for tokens, _ in buffer), default=0)
+        requests_per_minute = len(buffer)
+        return tokens_last_minute, max_single_request, requests_per_minute
+
+    @classmethod
+    def _reset_token_usage(cls, model=None):
+        """Clear the rolling token-usage buffer for one model, or all when model is None."""
+        if model is None:
+            UsageMeta._token_usage_buffer = {}
+        else:
+            UsageMeta._token_usage_buffer.pop(model, None)
+
 
 class Coder(metaclass=UsageMeta):
 
@@ -188,6 +234,10 @@ class Coder(metaclass=UsageMeta):
     def total_cached_tokens(self, value):
         type(self).total_cached_tokens = value
 
+    def _reset_token_usage(self):
+        """Clear rolling token usage after restoring a saved session."""
+        UsageMeta._reset_token_usage()
+
     abs_fnames = None
     abs_read_only_fnames = None
     abs_read_only_stubs_fnames = None
@@ -315,7 +365,7 @@ class Coder(metaclass=UsageMeta):
                 read_only_stubs_fnames=list(
                     from_coder.abs_read_only_stubs_fnames
                 ),  # Copy read-only stubs
-                rules_fnames=list(from_coder.abs_rules_fnames),  # Copy read-only stubs
+                rules_fnames=list(from_coder.abs_rules_fnames),  # Copy rules files
                 done_messages=[],
                 cur_messages=[],
                 coder_commit_hashes=from_coder.coder_commit_hashes,
@@ -2293,6 +2343,7 @@ class Coder(metaclass=UsageMeta):
 
                         asyncio.create_task(invoke_memorizer(self, additional_context=text))
 
+            await self._rate_limit_sleep()
             if done_tokens > self.context_compaction_max_tokens or done_tokens > cur_tokens:
                 await summarize_and_update(done_messages, MessageTag.DONE)
 
@@ -3756,6 +3807,7 @@ class Coder(metaclass=UsageMeta):
 
             while True:
                 try:
+                    await self._rate_limit_sleep(model)
                     completion_coro = model.send_completion(
                         messages,
                         functions,
@@ -3764,6 +3816,7 @@ class Coder(metaclass=UsageMeta):
                         tools=tools,
                         override_kwargs=self.model_kwargs.copy(),
                         interrupt_event=self.interrupt_event,
+                        uuid=self.uuid,
                     )
 
                     try:
@@ -3830,7 +3883,7 @@ class Coder(metaclass=UsageMeta):
             if response:
                 completion = response
             # Calculate costs for successful responses
-            self.calculate_and_show_tokens_and_cost(messages, completion)
+            self.calculate_and_show_tokens_and_cost(messages, completion, model=model)
 
         except litellm_ex.exceptions_tuple() as err:
             self.error_code = 1
@@ -3838,7 +3891,7 @@ class Coder(metaclass=UsageMeta):
             if ex_info.name == "ContextWindowExceededError":
                 # Still calculate costs for context window errors
                 self.token_profiler.on_error()
-                self.calculate_and_show_tokens_and_cost(messages, completion)
+                self.calculate_and_show_tokens_and_cost(messages, completion, model=model)
             raise
         except (KeyboardInterrupt, asyncio.CancelledError) as kbi:
             self.error_code = 130  # apparently standard?
@@ -4431,56 +4484,55 @@ class Coder(metaclass=UsageMeta):
             self.reasoning_tag_name,
         )
 
-    def calculate_and_show_tokens_and_cost(self, messages, completion=None):
+    def calculate_and_show_tokens_and_cost(self, messages, completion=None, model=None):
+        active_model = model or self.get_active_model()
         prompt_tokens = 0
         completion_tokens = 0
         cache_hit_tokens = 0
         cache_write_tokens = 0
+        usage = nested.getter(completion, "usage") if completion else None
 
         if (
-            completion
-            and nested.getter(completion, "usage.prompt_tokens") is not None
-            and nested.getter(completion, "usage.completion_tokens") is not None
+            usage is not None
+            and nested.getter(usage, ["prompt_tokens", "input_tokens"]) is not None
+            and nested.getter(usage, ["completion_tokens", "output_tokens"]) is not None
         ):
             prompt_tokens = (
-                nested.getter(completion.usage, "prompt_tokens", 0)
-                or nested.getter(completion.usage, "prompt_eval_count", 0)
-                or 0
+                nested.getter(usage, ["prompt_tokens", "input_tokens", "prompt_eval_count"], 0) or 0
             )
             completion_tokens = (
-                nested.getter(completion.usage, "completion_tokens", 0)
-                or nested.getter(completion.usage, "eval_count", 0)
-                or 0
+                nested.getter(usage, ["completion_tokens", "output_tokens", "eval_count"], 0) or 0
             )
             cache_hit_tokens = (
-                getattr(completion.usage, "prompt_cache_hit_tokens", 0)
-                or getattr(completion.usage, "cache_read_input_tokens", 0)
-                or nested.getter(completion.usage, "prompt_tokens_details.cached_tokens", 0)
+                nested.getter(
+                    usage,
+                    [
+                        "prompt_cache_hit_tokens",
+                        "cache_read_input_tokens",
+                        "input_tokens_details.cached_tokens",
+                        "prompt_tokens_details.cached_tokens",
+                    ],
+                    0,
+                )
                 or 0
             )
-            cache_write_tokens = getattr(completion.usage, "cache_creation_input_tokens", 0) or 0
+            cache_write_tokens = nested.getter(usage, "cache_creation_input_tokens", 0) or 0
             self.message_cached_tokens += cache_hit_tokens
-
-            # ``prompt_tokens`` is normalized to the full input (including any
-            # cache read/write) for anthropic usage, so no separate add here.
             self.message_tokens_sent += prompt_tokens
-
         else:
-            prompt_tokens = self.get_active_model().token_count(messages)
-            completion_tokens = self.get_active_model().token_count(self.partial_response_content)
+            prompt_tokens = active_model.token_count(messages)
+            completion_tokens = active_model.token_count(self.partial_response_content)
             self.message_tokens_sent += prompt_tokens
 
         self.message_tokens_received += completion_tokens
+        UsageMeta._record_token_usage(active_model.name, prompt_tokens)
 
-        # Build tokens string as "{prompt} CH {hit_rate:.1f}% ↑ {completion} ↓"
         if prompt_tokens > 0:
             hit_rate = round(cache_hit_tokens / prompt_tokens * 100, 1) if cache_hit_tokens else 0.0
         else:
             hit_rate = 0.0
         tokens_str = f"{format_tokens(prompt_tokens)} ◇ {hit_rate:.1f}%"
-
         tokens_report = f"{tokens_str} ↑ {format_tokens(completion_tokens)} ↓"
-
         tokens_report = self.token_profiler.add_to_usage_report(
             tokens_report, self.message_tokens_sent, self.message_tokens_received
         )
@@ -4503,36 +4555,31 @@ class Coder(metaclass=UsageMeta):
             total_hit_rate = 0.0
 
         total_stats = f"{format_tokens(total_combined_tokens)} ◇ {total_hit_rate:.1f}% ↑↓"
-
-        if not self.get_active_model().info.get("input_cost_per_token"):
+        if not active_model.info.get("input_cost_per_token"):
             self.usage_report = tokens_report + " " + total_stats
             return
 
         try:
-            # Try and use litellm's built in cost calculator. Seems to work for non-streaming only?
             cost = litellm.completion_cost(completion_response=completion)
         except Exception:
             cost = 0
 
         if not cost:
             cost = self.compute_costs_from_tokens(
-                prompt_tokens, completion_tokens, cache_write_tokens, cache_hit_tokens
+                prompt_tokens,
+                completion_tokens,
+                cache_write_tokens,
+                cache_hit_tokens,
+                model=active_model,
             )
 
         self.total_cost += cost
         self.message_cost += cost
-
         cost_report = (
             f"${self.format_cost(self.message_cost)} • {total_stats}"
             f" ${self.format_cost(self.total_cost)}"
         )
-
-        if cache_hit_tokens and cache_write_tokens:
-            sep = " "
-        else:
-            sep = " "
-
-        self.usage_report = tokens_report + sep + cost_report
+        self.usage_report = tokens_report + " " + cost_report
 
     def format_cost(self, value):
         if value == 0:
@@ -4544,31 +4591,24 @@ class Coder(metaclass=UsageMeta):
             return f"{value:.{max(2, 2 - int(math.log10(magnitude)))}f}"
 
     def compute_costs_from_tokens(
-        self, prompt_tokens, completion_tokens, cache_write_tokens, cache_hit_tokens
+        self, prompt_tokens, completion_tokens, cache_write_tokens, cache_hit_tokens, model=None
     ):
         cost = 0
+        active_model = model or self.get_active_model()
+        info = getattr(active_model, "info", {}) or {}
 
-        input_cost_per_token = self.get_active_model().info.get("input_cost_per_token") or 0
-        output_cost_per_token = self.get_active_model().info.get("output_cost_per_token") or 0
+        input_cost_per_token = info.get("input_cost_per_token") or 0
+        output_cost_per_token = info.get("output_cost_per_token") or 0
         input_cost_per_token_cache_hit = (
-            self.get_active_model().info.get("input_cost_per_token_cache_hit")
-            or self.get_active_model().info.get("cache_read_input_token_cost")
+            info.get("input_cost_per_token_cache_hit")
+            or info.get("cache_read_input_token_cost")
             or 0
         )
 
-        # deepseek
-        # prompt_cache_hit_tokens + prompt_cache_miss_tokens
-        #    == prompt_tokens == total tokens that were sent
-        #
-        # Anthropic
-        # cache_creation_input_tokens + cache_read_input_tokens + prompt
-        #    == total tokens that were
-
         if input_cost_per_token_cache_hit:
             cost += cache_hit_tokens * input_cost_per_token_cache_hit
             cost += (prompt_tokens - cache_hit_tokens) * input_cost_per_token
         else:
-            # hard code the anthropic adjustments, no-ops for other models since cache_x_tokens==0
             cost += cache_write_tokens * input_cost_per_token * 1.25
             cost += cache_hit_tokens * input_cost_per_token * 0.10
             cost += (prompt_tokens - cache_hit_tokens) * input_cost_per_token
@@ -4576,6 +4616,144 @@ class Coder(metaclass=UsageMeta):
         cost += completion_tokens * output_cost_per_token
         return cost
 
+    def record_background_usage_and_cost(self, messages, completion=None, model=None):
+        """Account for token usage and cost of a background model call."""
+        active_model = model or self.get_active_model()
+        prompt_tokens = 0
+        completion_tokens = 0
+        cache_hit_tokens = 0
+        cache_write_tokens = 0
+        usage = nested.getter(completion, "usage") if completion else None
+
+        if usage is not None:
+            prompt_tokens = (
+                nested.getter(usage, ["prompt_tokens", "input_tokens", "prompt_eval_count"], 0) or 0
+            )
+            completion_tokens = (
+                nested.getter(usage, ["completion_tokens", "output_tokens", "eval_count"], 0) or 0
+            )
+            cache_hit_tokens = (
+                nested.getter(
+                    usage,
+                    [
+                        "prompt_cache_hit_tokens",
+                        "cache_read_input_tokens",
+                        "input_tokens_details.cached_tokens",
+                        "prompt_tokens_details.cached_tokens",
+                    ],
+                    0,
+                )
+                or 0
+            )
+            cache_write_tokens = nested.getter(usage, "cache_creation_input_tokens", 0) or 0
+        elif active_model is not None:
+            prompt_tokens = active_model.token_count(messages) or 0
+
+        model_name = getattr(active_model, "name", None)
+        UsageMeta._record_token_usage(model_name, prompt_tokens)
+        self.total_tokens_sent += prompt_tokens
+        self.total_tokens_received += completion_tokens
+        self.total_cached_tokens += cache_hit_tokens
+
+        info = getattr(active_model, "info", {}) or {}
+        if not info.get("input_cost_per_token"):
+            return
+
+        try:
+            cost = litellm.completion_cost(completion_response=completion)
+        except Exception:
+            cost = 0
+
+        if not cost:
+            cost = self.compute_costs_from_tokens(
+                prompt_tokens,
+                completion_tokens,
+                cache_write_tokens,
+                cache_hit_tokens,
+                model=active_model,
+            )
+
+        self.total_cost += cost
+
+    def calculate_dynamic_sleep(self, model=None):
+        """Compute how long to sleep before the next LLM API call to stay under the configured per-minute token limit.
+
+        Uses the rolling token-usage buffer (last 60s) to estimate:
+
+        * ``used_last_min`` - prompt tokens already consumed in the window
+        * ``max_request`` - largest single request observed in the window
+        * ``requests_per_min`` - request rate observed in the window
+
+        Returns a sleep duration (seconds) that is ``0`` when the current
+        trajectory stays within 90% of ``tokens_per_minute`` both over the next
+        15 seconds and, if sustained, over a full minute. Otherwise it returns a
+        pause rounded up to the nearest 0.25s interval.
+        """
+        limit = nested.getter(
+            getattr(self, "args", None), "tokens_per_minute", DEFAULT_TOKENS_PER_MINUTE
+        )
+        if not isinstance(limit, (int, float)):
+            limit = DEFAULT_TOKENS_PER_MINUTE
+        if limit <= 0:
+            return 0.0
+
+        active_model = model or getattr(self, "main_model", None)
+        if active_model is None:
+            get_active_model = getattr(self, "get_active_model", None)
+            if callable(get_active_model):
+                active_model = get_active_model()
+
+        model_name = getattr(active_model, "name", None)
+        if not model_name:
+            return 0.0
+
+        budget = limit * 0.9
+        used_last_min, max_request, requests_per_min = UsageMeta._get_token_usage_stats(model_name)
+
+        if max_request <= 0 or requests_per_min <= 0:
+            # No recent usage to throttle.
+            return 0.0
+
+        # Tokens we would consume in the next 15 seconds at the current rate.
+        projected_15s = max_request * (requests_per_min / 60.0) * 15.0
+
+        # If the current trajectory stays within budget (both over the next 15s
+        # and if sustained for a full minute) there is nothing to do.
+        if (used_last_min + projected_15s) <= budget and (max_request * requests_per_min) <= budget:
+            return 0.0
+
+        # Slow the request rate so a sustained minute at max_request size fits
+        # the budget.
+        sustainable_rpm = budget / max_request
+        sustainable_interval = 60.0 / sustainable_rpm if sustainable_rpm > 0 else 60.0
+        current_interval = 60.0 / requests_per_min
+        sleep = max(0.0, sustainable_interval - current_interval)
+
+        # If the next 15 seconds (plus what we've already used) would breach the
+        # budget, wait for the rolling window to drain enough to absorb it.
+        overshoot = (used_last_min + projected_15s) - budget
+        if overshoot > 0:
+            drain = 60.0 * (overshoot / max(used_last_min, 1.0))
+            sleep = max(sleep, drain)
+
+        # Cap at one full window; round up to the nearest 0.25s.
+        sleep = min(sleep, UsageMeta._token_usage_window)
+        return math.ceil(sleep / 0.25) * 0.25
+
+    async def _rate_limit_sleep(self, model=None):
+        """Sleep (if needed) before an LLM API call to respect the per-minute token limit.
+
+        Best-effort: an interrupt simply skips the pause and is handled at the
+        next interruptible API point.
+        """
+        delay = self.calculate_dynamic_sleep(model=model)
+        if delay <= 0:
+            return
+
+        _, interrupted = await coroutines.interruptible(asyncio.sleep(delay), self.interrupt_event)
+        if interrupted:
+            return
+
     def show_usage_report(self):
         if not self.usage_report:
             return

{cecli_dev-1.5.0rc2 → cecli_dev-1.5.0rc3}/cecli/commands/voice.py

@@ -11,27 +11,31 @@ class VoiceCommand(BaseCommand):
 
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
-        """Execute the voice command with given parameters."""
-        # Get voice parameters from kwargs or coder.
+        """Record inline in the CLI, or toggle background recording in the TUI."""
+        tui = coder.tui() if coder.tui else None
+        stop_queue = kwargs.get("stop_queue")
+
+        if tui is not None and stop_queue is None:
+            tui.call_from_thread(tui.action_start_voice)
+            return ""
+
         voice_language = kwargs.get("voice_language") or getattr(coder, "voice_language", None)
         voice_format = kwargs.get("voice_format") or getattr(coder, "voice_format", None)
         voice_input_device = kwargs.get("voice_input_device") or getattr(
             coder, "voice_input_device", None
         )
 
-        # Resolve the Moonshine model language: an explicit voice-language
-        # setting, then the detected user/chat language, finally English.
         detected_language = None
         get_user_language = getattr(coder, "get_user_language", None)
+
         if get_user_language:
             detected_language = get_user_language()
 
         resolved_language = voice.resolve_moonshine_language(voice_language, detected_language)
-
-        # Get voice instance from kwargs or create new one.
         voice_instance = kwargs.get("voice_instance")
+        owns_voice = voice_instance is None
 
-        if not voice_instance:
+        if owns_voice:
             try:
                 import moonshine_voice  # noqa: F401
             except ImportError:
@@ -51,50 +55,50 @@ class VoiceCommand(BaseCommand):
                 return format_command_result(io, "voice", "Sound device error")
 
         def on_text(partial):
-            # Stream partial transcripts into the input field as they are generated.
-            if coder.tui and coder.tui():
-                coder.tui().set_input_value(partial)
-                coder.tui().refresh()
+            if tui is not None:
+                tui.set_input_value(partial)
+                tui.refresh()
             else:
                 io.placeholder = partial
 
         def on_status(message):
-            # Surface worker status messages (recording/transcribing) in the TUI.
-            if coder.tui and coder.tui():
-                if "Recording..." in str(message) or "Transcribing..." in str(message):
-                    io.update_spinner((message or "").strip())
+            if tui is not None:
+                if "⬤ recording" in str(message) or "⬤ Transcribing" in str(message):
+                    tui.set_voice_hint((message or "").strip())
                 else:
                     io.tool_output((message or "").strip())
             else:
                 io.tool_output(message or "")
 
-        stop_binding = None
-        if coder.tui and coder.tui():
-            try:
-                stop_binding = coder.tui().get_keys_for("submit")
-            except Exception:
-                stop_binding = None
+        stop_binding = tui.get_keys_for("voice") if tui is not None else None
 
         try:
-            io.update_spinner("Recording...")
+            if tui is not None:
+                tui.set_voice_hint("⬤ recording")
+            else:
+                io.update_spinner("⬤ recording")
             text = await voice_instance.record_and_transcribe(
                 None,
                 language=resolved_language,
                 on_text=on_text,
                 on_status=on_status,
                 stop_binding=stop_binding,
+                stop_queue=stop_queue,
             )
         except Exception as err:
             io.tool_error(f"Unable to transcribe: {err}")
             return format_command_result(io, "voice", f"Transcription error: {err}")
+        finally:
+            if owns_voice:
+                voice_instance.close()
 
         if text:
             io.placeholder = text
 
-            if coder.tui and coder.tui():
-                coder.tui().set_input_value(text)
-                coder.tui().refresh()
-                return ""  # For the TUI the result is already in the input field!
+            if tui is not None:
+                tui.set_input_value(text)
+                tui.refresh()
+                return ""
 
         return format_command_result(io, "voice", "Voice recorded and transcribed")
 
@@ -114,6 +118,11 @@ class VoiceCommand(BaseCommand):
             " using the Moonshine on-device model. The language is resolved from your"
             " /voice-language setting, falling back to your chat language, then English.\n"
         )
+        help_text += (
+            "\nIn the TUI, use the voice shortcut (Ctrl+R by default) to start and stop"
+            " background recording. /voice also toggles recording. Outside the TUI,"
+            " press Enter to stop.\n"
+        )
         help_text += "Requirements:\n"
         help_text += "  - moonshine-voice, sounddevice, and soundfile Python packages\n"
         help_text += "  - PortAudio library installed (for sounddevice)\n"

{cecli_dev-1.5.0rc2 → cecli_dev-1.5.0rc3}/cecli/helpers/agents/service.py

@@ -617,6 +617,10 @@ class AgentService:
             parent_uuid=parent_coder.uuid,
             map_tokens=0,
             init_metadata={"agent_config": agent_config},
+            # Sub-agents start with an empty file context; rules are inherited.
+            fnames=[],
+            read_only_fnames=[],
+            read_only_stubs_fnames=[],
         )
         if configured_root:
             kwargs["root"] = configured_root

{cecli_dev-1.5.0rc2 → cecli_dev-1.5.0rc3}/cecli/helpers/background_commands.py

@@ -43,14 +43,17 @@ class CircularBuffer:
         self.total_added = 0  # Track total characters added for new output detection
 
     def append(self, text: str) -> None:
-        """
-        Add text to buffer, removing oldest content if exceeds max size.
+        """Append text, retaining only the newest ``max_size`` characters.
 
-        Args:
-            text: Text to append to buffer
+        Store individual characters so the deque limit measures characters, not
+        output chunks. Slice oversized inputs before extending to avoid processing
+        characters that would immediately be evicted. Track all received characters
+        in ``total_added`` so incremental read positions survive eviction.
         """
         with self.lock:
-            self.buffer.append(text)
+            if self.max_size:
+                self.buffer.extend(text[-self.max_size :])
+
             self.total_added += len(text)
 
     def get_all(self, clear: bool = False) -> str:
@@ -100,7 +103,7 @@ class CircularBuffer:
     def size(self) -> int:
         """Get current buffer size in characters."""
         with self.lock:
-            return sum(len(chunk) for chunk in self.buffer)
+            return len(self.buffer)
 
 
 class InputBuffer: