voidx 3.4.0__tar.gz → 3.4.2__tar.gz

voidx-3.4.2/LICENSE

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

{voidx-3.4.0 → voidx-3.4.2}/PKG-INFO

@@ -1,9 +1,12 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 3.4.0
+Version: 3.4.2
 Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
+Author: chikhamx
+License: MIT
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: langgraph>=0.3.0
 Requires-Dist: langchain>=0.3.0
 Requires-Dist: langchain-anthropic>=0.3.0
@@ -23,6 +26,7 @@ Provides-Extra: dev
 Requires-Dist: build>=1.2.0; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.25.0; extra == "dev"
+Dynamic: license-file
 
 # voidx
 

{voidx-3.4.0 → voidx-3.4.2}/pyproject.toml

@@ -2,6 +2,8 @@
 name = "voidx"
 dynamic = ["version"]
 description = "A coding agent that quantifies everything and solves with tools, not fuzzy prompts."
+license = {text = "MIT"}
+authors = [{name = "chikhamx"}]
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/__init__.py

@@ -1,3 +1,3 @@
 """VoidX - A coding agent that quantifies everything."""
 
-__version__ = "3.4.0"
+__version__ = "3.4.2"

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/agent/attachments.py

@@ -152,9 +152,23 @@ def is_image_path(path: Path | str) -> bool:
     return Path(path).suffix.lower() in IMAGE_EXTENSIONS
 
 
+_PASTED_RE = re.compile(r"<pasted>\n.*?\n</pasted>", re.DOTALL)
+
+
+def _pasted_spans(text: str) -> list[tuple[int, int]]:
+    """Return (start, end) spans of all <pasted>...</pasted> blocks."""
+    return [(m.start(), m.end()) for m in _PASTED_RE.finditer(text)]
+
+
 def _attachment_tokens(text: str) -> list[tuple[int, int, str]]:
     tokens: list[tuple[int, int, str]] = []
+    excluded = _pasted_spans(text)
     for match in _ATTACHMENT_RE.finditer(text):
+        # Skip @-references and [image-] tokens inside <pasted> blocks —
+        # pasted content is quoted material (e.g. code with decorators),
+        # not user-authored attachment references.
+        if any(start <= match.start() < end for start, end in excluded):
+            continue
         image_stem = match.group(3)
         if image_stem:
             raw_path = f":image:{image_stem}"

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/agent/graph/run_loop.py

@@ -169,7 +169,7 @@ class GraphRunLoopMixin(GraphTurnMixin, GraphSessionMixin, GraphTranscriptMixin)
                 model=self.config.model.model,
                 workspace=self._workspace,
                 session_title=title,
-                context_limit=get_context_limit(self.config.model.provider),
+                context_limit=get_context_limit(self.config.model.provider, self.config.model.protocol or "", self.config.model.context_window),
                 reasoning_effort=self.config.model.reasoning_effort or "xhigh",
                 permission_label=self._permission.status_label,
                 sandbox_label=lambda: self._permission._sandbox_label(),

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/agent/graph/wiring.py

@@ -74,7 +74,7 @@ def build_permission_service(config: Config, *, notifier: Callable[[str], object
 
 
 def build_compaction_service(config: Config) -> tuple[UsageStats, CompactionService]:
-    context_limit = get_context_limit(config.model.provider)
+    context_limit = get_context_limit(config.model.provider, config.model.protocol or "", config.model.context_window)
     return (
         UsageStats(context_limit=context_limit),
         CompactionService(

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/agent/slash/handler.py

@@ -146,6 +146,9 @@ class SlashHandler(
         elif args == "reasoning" or args.startswith("reasoning "):
             target = args.removeprefix("reasoning").strip()
             await self._model_reasoning(target)
+        elif args == "ctx" or args.startswith("ctx "):
+            target = args.removeprefix("ctx").strip()
+            await self._model_ctx(target)
         elif args:
             await self._switch_model(args)
         else:

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/agent/slash/model.py

@@ -190,7 +190,7 @@ class SlashModelMixin:
             else:
                 ui.print("[dim](none)[/dim]")
         ui.print()
-        ui.print("[dim]Usage: /model list|new|reasoning|test|del|switch|<name>[/dim]")
+        ui.print("[dim]Usage: /model list|new|reasoning|ctx|test|del|switch|<name>[/dim]")
 
     async def _model_list(self) -> None:
         cfg = self.host.config
@@ -341,6 +341,45 @@ class SlashModelMixin:
 
         ui.print(f"Reasoning effort: [cyan]{new_effort}[/cyan] [green]✓[/green]")
 
+    async def _model_ctx(self, target: str) -> None:
+        choices_map: dict[str, int | None] = {
+            "128k": 128_000,
+            "256k": 256_000,
+            "384k": 384_000,
+            "512k": 512_000,
+            "1M": 1_000_000,
+            "Auto": None,
+        }
+
+        if target:
+            key = target.lower()
+            normalized = {c.lower(): (c, v) for c, v in choices_map.items()}
+            if key not in normalized:
+                ui.error(f"Invalid context window: '{target}'. Use: {', '.join(choices_map)}")
+                return
+            new_label, new_value = normalized[key]
+        else:
+            choices = list(choices_map)
+            idx = await _select_from_list(self.host.app, "Context window", choices)
+            if idx is None:
+                ui.print("[dim]Cancelled.[/dim]")
+                return
+            new_value = choices_map[choices[idx]]
+            new_label = choices[idx]
+
+        self.host.config.model.context_window = new_value
+        self._sync_context_limit()
+
+        settings = self.host.settings
+        if settings is not None:
+            if new_value is None:
+                settings._pop_setting("context_window")
+            else:
+                settings._set_setting("context_window", new_value)
+
+        display = "Auto (provider default)" if new_value is None else f"{new_label}"
+        ui.print(f"Context window: [cyan]{display}[/cyan] [green]✓[/green]")
+
     async def _switch_model(self, model_spec: str) -> None:
         from voidx.llm.service import create_chat_model
         from voidx.memory.service import update_session_model
@@ -412,7 +451,7 @@ class SlashModelMixin:
     def _sync_context_limit(self) -> None:
         from voidx.llm.service import get_context_limit
 
-        limit = get_context_limit(self.host.config.model.provider)
+        limit = get_context_limit(self.host.config.model.provider, self.host.config.model.protocol or "", self.host.config.model.context_window)
         stats = self.host.usage_stats
         if stats is not None:
             stats.context_limit = limit

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/config/models.py

@@ -32,6 +32,11 @@ class ModelConfig(BaseModel):
         default="xhigh",
         description="Reasoning intensity: off, low, medium, high, xhigh, or None (provider default)",
     )
+    context_window: int | None = Field(
+        default=None,
+        ge=1,
+        description="Override context window size in tokens. None = auto-detect by provider.",
+    )
 
 
 class AgentConfig(BaseModel):

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/config/settings.py

@@ -312,7 +312,7 @@ class Settings(
             base_url = None
             protocol = None
 
-        cfg = ModelConfig(provider=provider, model=model, base_url=base_url)
+        cfg = ModelConfig(provider=provider, model=model, base_url=base_url, context_window=self._effective_data().get("context_window"))
         if protocol:
             cfg.protocol = protocol
         permission_mode = self.get_permission_mode()

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/llm/provider.py

@@ -584,8 +584,10 @@ def extract_thinking(chunk: AIMessageChunk, protocol: str) -> str:
 
 # ── context limits ────────────────────────────────────────────────────────
 
-def get_context_limit(provider: str, protocol: str = "") -> int:
+def get_context_limit(provider: str, protocol: str = "", context_window: int | None = None) -> int:
     """Return context-window limit for *provider*.  Falls back to *protocol* for unknown providers."""
+    if context_window is not None and context_window > 0:
+        return context_window
     limits: dict[str, int] = {
         PROTOCOL_DEEPSEEK: 1_000_000,
         "anthropic": 200_000,

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/llm/service.py

@@ -21,8 +21,8 @@ def extract_thinking(chunk: AIMessageChunk, protocol: str) -> str:
     return provider.extract_thinking(chunk, protocol)
 
 
-def get_context_limit(provider_name: str, protocol: str = "") -> int:
-    return provider.get_context_limit(provider_name, protocol)
+def get_context_limit(provider_name: str, protocol: str = "", context_window: int | None = None) -> int:
+    return provider.get_context_limit(provider_name, protocol, context_window)
 
 __all__ = [
     "create_chat_model",

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/tools/file_ops/edit_execute.py

@@ -158,6 +158,12 @@ async def _execute_text_replace(
 
     lines = list(display.lines)
     new_lines = _split_edit_lines(new_string)
+    if (
+        start_line == end_line
+        and new_string in ("", "\n", " ")
+        and lines[start_line - 1] != ""
+    ):
+        new_lines = []
     lines[start_line - 1:end_line] = new_lines
 
     # Head-line dedup: if the first line of new_string exactly matches the

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/ui/commands.py

@@ -49,6 +49,7 @@ COMMANDS: list[tuple[str, str]] = [
     ("/mode goal", "Keep multi-step work scoped"),
     ("/mode plan", "Read-only plan mode"),
     ("/model", "Switch configured model"),
+    ("/model ctx", "Set context window size"),
     ("/model del", "Remove a profile"),
     ("/model list", "Show configured model details"),
     ("/model new", "Create or update a model profile"),

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/ui/output/dock/app.py

@@ -7,13 +7,14 @@ from typing import Any, Callable, Sequence
 
 from rich.console import Console, Group
 from rich.live import Live
-from rich.markup import escape
 from rich.text import Text
 
+from rich.markup import escape
+
 from voidx.ui.output.dock.formatting import (
     ANSI_LINE_PREFIX,
     _clean,
-    _strip_ansi_trailing_space,
+    _PASTED_RE,
     _text_from_line,
 )
 from voidx.ui.output.dock.nodes import DockNodeMixin
@@ -219,18 +220,33 @@ class BottomInputDock(DockStreamMixin, DockStatusMixin, DockNodeMixin):
         if self._tree.root.children:
             self._append_root_spacer()
         preview = _clean(text)
-        lines = [_strip_ansi_trailing_space(line) for line in (preview.splitlines() or [preview])]
+        preview = _PASTED_RE.sub(r"\1", preview)
+        header, body_lines = self._render_turn_text(preview)
+        header = f"[bold white]❯[/] {header}" if header else "[bold white]❯[/]"
         self._current_turn = self._tree.new_node(
             parent=self._tree.root,
             node_type="turn",
-            header=f"[bold white]❯[/] {escape(lines[0])}",
-            body_lines=[escape(line) for line in lines[1:]],
+            header=header,
+            body_lines=body_lines,
             collapsed=False,
         )
         self._mark_settled(self._current_turn)
         self.refresh()
         return self._current_turn
 
+    def _render_turn_text(self, text: str) -> tuple[str, list[str]]:
+        """Render user turn text into (header, body_lines) as plain text.
+
+        <pasted> wrapper tags are stripped (content kept), then the entire
+        text is rendered as escaped plain text — no markdown formatting.
+        """
+        lines = text.splitlines() or [text] if text else []
+        if not lines:
+            return "", []
+        header = escape(lines[0])
+        body_lines = [escape(line) for line in lines[1:]]
+        return header, body_lines
+
     def ensure_agent(self) -> OutputNode:
         if self._current_agent is None:
             self._append_root_spacer()

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/ui/output/dock/formatting.py

@@ -92,6 +92,25 @@ def _strip_ansi_trailing_space(line: str) -> str:
     return buffer.getvalue()
 
 
+_PASTED_RE = re.compile(r"<pasted>\n(.*?)\n</pasted>", re.DOTALL)
+
+
+def split_pasted_segments(text: str) -> list[tuple[bool, str]]:
+    """Split text into (is_pasted, content) segments by <pasted> blocks."""
+    segments: list[tuple[bool, str]] = []
+    pos = 0
+    for match in _PASTED_RE.finditer(text):
+        if match.start() > pos:
+            segments.append((False, text[pos:match.start()]))
+        segments.append((True, match.group(1)))
+        pos = match.end()
+    if pos < len(text):
+        segments.append((False, text[pos:]))
+    if not segments:
+        segments.append((False, text))
+    return segments
+
+
 def short_value(value: object) -> str:
     text = str(value).replace("\n", "\\n")
     return text[:157] + "..." if len(text) > 160 else text

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/ui/output/tree.py

@@ -14,6 +14,27 @@ from rich.text import Text
 USER_ROW_STYLE = "white on #3a3937"
 TOOL_META_BRANCH = "[dim]└[/dim] "
 
+# Must match voidx.ui.output.dock.formatting.ANSI_LINE_PREFIX.
+# Duplicated here to avoid circular imports (formatting imports from dock,
+# dock imports from tree).
+_ANSI_LINE_PREFIX = "\x00voidx-ansi\x00"
+
+
+def _visible_len(line: str) -> int:
+    """Compute visible cell length of a render line safely.
+
+    Lines may contain an ANSI_LINE_PREFIX marker separating rich-markup text
+    from ANSI-styled text (pasted segments).  The ANSI portion can contain
+    arbitrary characters including ``[/]`` that would crash Text.from_markup,
+    so it is parsed with Text.from_ansi instead.
+    """
+    marker = line.find(_ANSI_LINE_PREFIX)
+    if marker == -1:
+        return cell_len(Text.from_markup(line).plain)
+    text = Text.from_markup(line[:marker])
+    text.append_text(Text.from_ansi(line[marker + len(_ANSI_LINE_PREFIX):]))
+    return cell_len(text.plain)
+
 
 @dataclass
 class OutputNode:
@@ -617,15 +638,29 @@ class OutputTree:
 
 
 def _full_width_row(line: str, width: int) -> str:
-    visible = cell_len(Text.from_markup(line).plain)
+    visible = _visible_len(line)
     padding = " " * max(0, width - visible)
-    return f"[{USER_ROW_STYLE}]{line}{padding}[/]"
+    return _wrap_full_width(line, padding, USER_ROW_STYLE)
 
 
 def _permission_row(line: str, width: int) -> str:
-    visible = cell_len(Text.from_markup(line).plain)
+    visible = _visible_len(line)
     padding = " " * max(0, width - visible)
-    return f"[white on #3a3937]{line}{padding}[/]"
+    return _wrap_full_width(line, padding, "white on #3a3937")
+
+
+def _wrap_full_width(line: str, padding: str, style: str) -> str:
+    """Wrap a line with a background style and padding to full width.
+
+    When the line contains an ANSI_LINE_PREFIX marker, the closing tag and
+    padding must go *before* the marker so that _text_from_line parses them
+    with Text.from_markup (which understands tags) rather than leaving them
+    as literal text in the Text.from_ansi portion.
+    """
+    marker = line.find(_ANSI_LINE_PREFIX)
+    if marker == -1:
+        return f"[{style}]{line}{padding}[/]"
+    return f"[{style}]{line[:marker]}{padding}[/]{line[marker:]}"
 
 
 def _is_full_width_user_row(node: OutputNode) -> bool:
@@ -644,7 +679,7 @@ def _pad_diff_background_row(line: str, width: int) -> str:
         marker = "[/on #4a0000]"
     if not marker:
         return line
-    visible = cell_len(Text.from_markup(line).plain)
+    visible = _visible_len(line)
     padding = " " * max(0, width - visible)
     return line.replace(marker, f"{padding}{marker}", 1)
 

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/ui/tui/input.py

@@ -52,12 +52,15 @@ class _InputEditorMixin:
 
     def _register_text_paste(self, text: str) -> str:
         paste_id = self._paste_next_id
+        display = self._compute_text_paste_display(paste_id, text)
+        return self._register_paste_entry(kind="text", display=display, expanded=text)
+
+    @staticmethod
+    def _compute_text_paste_display(paste_id: int, text: str) -> str:
         line_count = len(text.split("\n"))
         if line_count > 1:
-            display = f"[Pasted text #{paste_id} +{line_count - 1} lines]"
-        else:
-            display = f"[Pasted text #{paste_id} {len(text)} chars]"
-        return self._register_paste_entry(kind="text", display=display, expanded=text)
+            return f"[Pasted text #{paste_id} +{line_count - 1} lines]"
+        return f"[Pasted text #{paste_id} {len(text)} chars]"
 
     def _register_image_paste(self, stem: str, size: int) -> str:
         from voidx.ui.tools.attachment_tokens import image_attachment_token_text
@@ -80,6 +83,8 @@ class _InputEditorMixin:
             display = str(entry.get("display", ""))
             expanded = str(entry.get("expanded", ""))
             if display:
+                if entry.get("kind") == "text":
+                    expanded = f"<pasted>\n{expanded}\n</pasted>"
                 result = result.replace(display, expanded)
         return result
 
@@ -343,3 +348,23 @@ class _InputEditorMixin:
         self._cursor_col = col + len(token)
         self._clear_attachment_suppression_on_edit()
         self._update_input_panels()
+
+    def _replace_token_in_editor(self, old_token: str, new_token: str) -> None:
+        """Replace a token string in the input with an updated version.
+
+        Used when merging split-batch pastes: the old token (e.g.
+        "[Pasted text #1 +3 lines]") is replaced in-place by the new
+        token (e.g. "[Pasted text #1 +4 lines]") with updated line count.
+        """
+        self._reset_ctrl_c()
+        line = self._current_line()
+        idx = line.rfind(old_token)
+        if idx == -1:
+            # Token not found on current line — fall back to inserting new
+            self._insert_text_token(new_token)
+            return
+        new_line = line[:idx] + new_token + line[idx + len(old_token):]
+        self._set_current_line(new_line)
+        self._cursor_col = idx + len(new_token)
+        self._clear_attachment_suppression_on_edit()
+        self._update_input_panels()

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/ui/tui/panels.py

@@ -7,6 +7,7 @@ from typing import Any
 
 from voidx.config import Settings
 from voidx.skills.service import SkillRegistry, SkillService
+from voidx.ui.output.dock.formatting import _PASTED_RE
 from voidx.ui.tools.attachment_tokens import attachment_token_text
 from voidx.ui.tools.file_picker import (
     AttachmentToken,
@@ -37,7 +38,12 @@ class _PanelManagerMixin:
     # ── submit ───────────────────────────────────────────────────────────
 
     def _submit_text_prompt(self) -> None:
-        value = self._get_input_text()
+        value = self._expand_registered_tokens(self._get_input_text())
+        # Clarify answers are plain text — strip <pasted> wrapper tags that
+        # _expand_registered_tokens adds (those tags are only consumed by the
+        # main input path's split_pasted_segments in start_turn rendering).
+        value = _PASTED_RE.sub(r"\1", value)
+        self._paste_entries.clear()
         self._text_queue.put_nowait(value)
 
     def _cancel_text_prompt(self) -> None:

{voidx-3.4.0 → voidx-3.4.2}/src/voidx/ui/tui/parser.py

@@ -77,30 +77,45 @@ class _InputParserMixin:
                 if mapped:
                     return mapped.encode("utf-8")
                 return ("\x00" + ch2).encode("utf-8")
-            # Newline first char: try to drain a paste
-            if ch in ("\r", "\n"):
-                pasted = self._try_drain_win32_paste(ch)
-                if pasted is not None:
-                    return pasted
-                return ch.encode("utf-8")
+            # Any character could be the start of a paste. Probe for
+            # quickly-following chars; if they look like a paste (multiple
+            # newlines or a long run), wrap the whole thing as bracketed
+            # paste. This fixes the case where pasted text starts with a
+            # regular char (e.g. "line1\r\nline2") — previously only
+            # newline-first pastes triggered the drain, so the leading
+            # "line1" was inserted char-by-char while the rest became a
+            # partial [Pasted text] token.
+            pasted = self._try_drain_win32_paste(ch)
+            if pasted is not None:
+                return pasted
             return ch.encode("utf-8")
 
         return await asyncio.to_thread(_read)
 
     def _try_drain_win32_paste(self, first_char: str, timeout_ms: int = 20) -> bytes | None:
-        """Drain remaining console input after a newline to detect a paste.
-
-        Windows Terminal injects pasted content character-by-character into the
-        console input buffer. When the first character is ``\\r`` or ``\\n``,
-        this method reads any quickly-following characters and, if they look
-        like a paste (multiple newlines or a long run), wraps them in a
-        bracketed-paste sequence so ``_process_paste`` handles them as a unit.
-        Returns the bracketed-paste bytes, or ``None`` if this is not a paste.
+        """Drain remaining console input to detect a paste.
+
+        Windows Terminal injects pasted content character-by-character into
+        the console input buffer. This method reads any quickly-following
+        characters after ``first_char`` and, if they look like a paste
+        (multiple newlines or a long run), wraps them in a bracketed-paste
+        sequence so ``_process_paste`` handles them as a unit.
+
+        Returns the bracketed-paste bytes when the drained content looks
+        like a paste. Returns the raw bytes of ALL drained characters
+        (including ``first_char``) when they don't look like a paste —
+        this lets the caller process them in arrival order without
+        stashing extras into ``_pending_bytes``, which previously caused
+        IME/keyboard characters to be reordered across reads. Returns
+        ``None`` when nothing follows ``first_char`` (a single keypress).
         """
         import msvcrt
         import time
 
-        if first_char not in ("\r", "\n"):
+        # Quick exit: if nothing follows immediately, this is a single
+        # keypress (normal typing), not a paste. Avoids entering the poll
+        # loop for every ordinary character.
+        if not msvcrt.kbhit():
             return None
 
         buffer = first_char
@@ -121,7 +136,11 @@ class _InputParserMixin:
         newline_count = buffer.count("\r") + buffer.count("\n")
         if newline_count >= 2 or len(buffer) > 8:
             return b"\x1b[200~" + buffer.encode("utf-8", errors="replace") + b"\x1b[201~"
-        return None
+        # Not a paste: return all drained chars as raw bytes so the caller
+        # processes them in arrival order. Previously, only first_char was
+        # returned and the rest was stashed in _pending_bytes, which caused
+        # fast IME/keyboard input to be reordered across reads.
+        return buffer.encode("utf-8", errors="replace")
 
     async def _read_input_line(self) -> bytes:
         """Fallback: read a line from stdin (not a tty)."""
@@ -231,16 +250,38 @@ class _InputParserMixin:
             return
         # Normalise line endings: \r\n → \n, \r → \n
         text = text.replace("\r\n", "\n").replace("\r", "\n")
-        if len(text.split("\n")) > 3 or len(text) > 200:
+        # All pasted text collapses to a [Pasted text #N ...] token, regardless
+        # of length. This keeps the input box compact and clearly marks pasted
+        # content as a distinct unit.
+        #
+        # Merge with the previous paste if it happened within a short window.
+        # Windows Terminal may split a large paste across multiple drain
+        # batches (20ms timeout fires between batches), producing two
+        # bracketed-paste sequences. Without merging, the user sees two
+        # adjacent tokens for what was a single paste action.
+        import time
+
+        now = time.monotonic()
+        last = getattr(self, "_last_paste_time", None)
+        self._last_paste_time = now
+
+        if (
+            last is not None
+            and (now - last) < 0.2
+            and self._paste_entries
+            and self._paste_entries[-1].get("kind") == "text"
+        ):
+            # Append to the previous paste entry
+            entry = self._paste_entries[-1]
+            combined = str(entry["expanded"]) + text
+            old_display = str(entry["display"])
+            new_display = self._compute_text_paste_display(int(entry["id"]), combined)
+            entry["expanded"] = combined
+            entry["display"] = new_display
+            # Replace the old token in the editor with the updated one
+            self._replace_token_in_editor(old_display, new_display)
+        else:
             self._insert_text_token(self._register_text_paste(text))
-            return
-        # Split into lines and insert each, creating editor newlines
-        lines = text.split("\n")
-        for i, line in enumerate(lines):
-            if i > 0:
-                self._insert_newline()
-            if line:
-                self._insert_text(line)
 
     def _dispatch_key(self, data: bytes, offset: int) -> tuple[int, str | None]:
         """Parse a key sequence starting at offset. Returns (bytes_consumed, action)."""

{voidx-3.4.0 → voidx-3.4.2}/src/voidx.egg-info/PKG-INFO

@@ -1,9 +1,12 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 3.4.0
+Version: 3.4.2
 Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
+Author: chikhamx
+License: MIT
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: langgraph>=0.3.0
 Requires-Dist: langchain>=0.3.0
 Requires-Dist: langchain-anthropic>=0.3.0
@@ -23,6 +26,7 @@ Provides-Extra: dev
 Requires-Dist: build>=1.2.0; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.25.0; extra == "dev"
+Dynamic: license-file
 
 # voidx
 

{voidx-3.4.0 → voidx-3.4.2}/src/voidx.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 pyproject.toml
 src/voidx/__init__.py