voidx 3.4.0__tar.gz → 3.4.1__tar.gz

voidx-3.4.1/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.1}/PKG-INFO

@@ -1,9 +1,12 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 3.4.0
+Version: 3.4.1
 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.1}/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.1}/src/voidx/__init__.py

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

{voidx-3.4.0 → voidx-3.4.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/src/voidx/ui/output/dock/app.py

@@ -12,9 +12,12 @@ from rich.text import Text
 
 from voidx.ui.output.dock.formatting import (
     ANSI_LINE_PREFIX,
+    _ansi_line,
     _clean,
+    _markdown_lines,
     _strip_ansi_trailing_space,
     _text_from_line,
+    split_pasted_segments,
 )
 from voidx.ui.output.dock.nodes import DockNodeMixin
 from voidx.ui.output.dock.stream import DockStreamMixin
@@ -219,18 +222,55 @@ 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])]
+        segments = split_pasted_segments(preview)
+        header, body_lines = self._render_turn_segments(segments)
         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=f"[bold white]❯[/] {header}",
+            body_lines=body_lines,
             collapsed=False,
         )
         self._mark_settled(self._current_turn)
         self.refresh()
         return self._current_turn
 
+    def _render_turn_segments(
+        self, segments: list[tuple[bool, str]]
+    ) -> tuple[str, list[str]]:
+        """Render (is_pasted, content) segments into (header, body_lines).
+
+        Non-pasted segments use escape() plain text (existing behavior).
+        Pasted segments use _markdown_lines() with _ansi_line() wrapping.
+        """
+        header = ""
+        body_lines: list[str] = []
+        width = self._markdown_width()
+        for index, (is_pasted, content) in enumerate(segments):
+            if is_pasted:
+                md_lines = [
+                    _ansi_line(line)
+                    for line in _markdown_lines(content, width)
+                ]
+                if index == 0 and md_lines:
+                    header = md_lines[0]
+                    body_lines.extend(md_lines[1:])
+                else:
+                    body_lines.extend(md_lines)
+            else:
+                lines = [
+                    _strip_ansi_trailing_space(line)
+                    for line in ((content.splitlines() or [content]) if content else [])
+                ]
+                if index == 0 and lines:
+                    header = escape(lines[0])
+                    body_lines.extend(escape(line) for line in lines[1:])
+                else:
+                    body_lines.extend(escape(line) for line in lines)
+        if not header and body_lines:
+            header = body_lines.pop(0)
+        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.1}/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.1}/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.1}/src/voidx/ui/tui/parser.py

@@ -77,30 +77,41 @@ 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.
+        """Drain remaining console input 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.
+        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.
+
+        Works with ANY first character, not just newlines — pasted text
+        often starts with a regular character (e.g. "line1\\r\\nline2").
         Returns the bracketed-paste bytes, or ``None`` if this is not a paste.
         """
         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,6 +132,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~"
+        # Not a paste: preserve any extra chars we consumed so they are
+        # processed on the next _process_input call instead of being lost.
+        extra = buffer[1:]
+        if extra:
+            self._pending_bytes = extra.encode("utf-8", errors="replace")
         return None
 
     async def _read_input_line(self) -> bytes:
@@ -231,16 +247,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.1}/src/voidx.egg-info/PKG-INFO

@@ -1,9 +1,12 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 3.4.0
+Version: 3.4.1
 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.1}/src/voidx.egg-info/SOURCES.txt

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