tau-coding-agent 0.7.8__tar.gz → 0.7.9__tar.gz

{tau_coding_agent-0.7.8/tau_coding_agent.egg-info → tau_coding_agent-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.7.8
+Version: 0.7.9
 Summary: A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{tau_coding_agent-0.7.8 → tau_coding_agent-0.7.9}/docs/auth.md

@@ -145,6 +145,7 @@ The provider ID used as the key in `auth.json` and the `{PROVIDER}_API_KEY` env
 | Mistral | `mistral` | `MISTRAL_API_KEY` |
 | Fireworks AI | `fireworks` | `FIREWORKS_API_KEY` |
 | Hugging Face | `huggingface` | `HUGGINGFACE_API_KEY` |
+| Subconscious | `subconscious` | `SUBCONSCIOUS_API_KEY` |
 | Ollama | `ollama` | None required (local server, default `http://localhost:11434`) |
 
 ## Next Steps

{tau_coding_agent-0.7.8 → tau_coding_agent-0.7.9}/docs/inference-providers.md

@@ -8,8 +8,8 @@ Tau supports the following inference providers:
 
 Built-in API-key providers are `openai`, `anthropic`, `google`, `nvidia`,
 `groq`, `openrouter`, `perplexity`, `xai`, `bedrock`, `kimi`, `minimax`,
-`cerebras`, `deepseek`, `zai`, `kilocode`, `fireworks`, `huggingface`, and
-`mistral`.
+`cerebras`, `deepseek`, `zai`, `kilocode`, `fireworks`, `huggingface`,
+`subconscious`, and `mistral`.
 
 Tau also includes local `ollama`, Google/Anthropic/OpenAI-compatible Vertex AI
 providers, and OAuth providers for OpenAI Codex, Claude Code, GitHub Copilot,
@@ -161,6 +161,36 @@ tau --model huggingface/deepseek-ai/DeepSeek-V3-0324 -p "Say hello"
 - Model IDs are Hugging Face Hub repo IDs (e.g. `meta-llama/Llama-3.3-70B-Instruct`)
 - Built-in model entries are pinned to a specific backend with `<repo>:<provider>` (e.g. `openai/gpt-oss-120b:groq`) rather than the router's default `:fastest` routing, since unpinned routing can silently switch to a backend with different tool-calling behavior. You can still use any model/backend combination the router supports via `tau --model huggingface/<repo>[:<provider>]` even if it isn't in the built-in list.
 
+## Subconscious
+
+Subconscious provides hosted inference through OpenAI-compatible Chat Completions
+and Anthropic-compatible Messages APIs. Tau uses Chat Completions because dashboard
+keys with the documented `sky_` prefix authenticate through Bearer authorization on
+that endpoint.
+
+### Setup
+
+1. Create an account at [Subconscious](https://www.subconscious.dev/)
+2. Generate an API key in the dashboard
+3. Set the environment variable:
+
+```bash
+export SUBCONSCIOUS_API_KEY=...
+```
+
+### Verify
+
+```bash
+tau --model subconscious/subconscious/tim-qwen3.6-27b -p "Say hello"
+```
+
+### Notes
+
+- The built-in model ID is `subconscious/tim-qwen3.6-27b`; the advertised `subconscious/glm-5.2` is omitted because the live API currently rejects it as an unknown model
+- `TIM-Qwen3.6 27B` is published as multimodal with optional thinking; Tau enables its documented image modality and thinking selector
+- Subconscious does not publish numeric context-window or maximum-output limits, so Tau leaves those fields unspecified rather than guessing
+- Model availability and pricing come from the [official pricing page](https://www.subconscious.dev/pricing)
+
 ## Ollama (Local)
 
 Run open-source models locally without API keys or internet.

{tau_coding_agent-0.7.8 → tau_coding_agent-0.7.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.7.8"
+version = "0.7.9"
 description = "A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands"
 readme = "README.md"
 requires-python = ">=3.12"

{tau_coding_agent-0.7.8 → tau_coding_agent-0.7.9}/tau/builtins/extensions/todo/__init__.py

@@ -64,7 +64,7 @@ class TodoBoard:
 
         glyphs = {
             "pending": ("☐", theme.muted),
-            "in_progress": ("■", theme.warning),
+            "in_progress": ("■", theme.accent),
             "done": ("✓", theme.success),
             "failed": ("✗", theme.error),
         }

{tau_coding_agent-0.7.8 → tau_coding_agent-0.7.9}/tau/builtins/models/text.py

@@ -7349,4 +7349,19 @@ models = [
         input=_TEXT_IMAGE,
         output=_TEXT,
     ),
+    # Subconscious. The provider publishes prices but not numeric context/output limits,
+    # so leave context_window unknown (0) and retain Tau's conservative 16K output default.
+    # Chat Completions is used because dashboard `sky_` keys authenticate through its
+    # Bearer scheme; the same key is rejected by the Anthropic-compatible endpoint.
+    Model(
+        id="subconscious/tim-qwen3.6-27b",
+        name="TIM-Qwen3.6 27B",
+        provider="subconscious",
+        cost=Cost(input=0.30, output=3.00, cache_read=0.15),
+        thinking=True,
+        thinking_format="chat-template",
+        context_window=0,
+        input=_TEXT_IMAGE,
+        output=_TEXT,
+    ),
 ]

{tau_coding_agent-0.7.8 → tau_coding_agent-0.7.9}/tau/builtins/providers/text.py

@@ -9,24 +9,9 @@ from tau.inference.provider.types import APIProvider
 from tau.inference.types import AuthType, LLMOptions
 
 api_providers = [
-    APIProvider(
-        id="openai",
-        name="OpenAI",
-        api="openai_responses",
-        options=LLMOptions()
-    ),
-    APIProvider(
-        id="anthropic",
-        name="Anthropic",
-        api="anthropic_messages",
-        options=LLMOptions()
-    ),
-    APIProvider(
-        id="google",
-        name="Google",
-        api="gemini_generate",
-        options=LLMOptions()
-    ),
+    APIProvider(id="openai", name="OpenAI", api="openai_responses", options=LLMOptions()),
+    APIProvider(id="anthropic", name="Anthropic", api="anthropic_messages", options=LLMOptions()),
+    APIProvider(id="google", name="Google", api="gemini_generate", options=LLMOptions()),
     APIProvider(
         id="google-vertex",
         name="Google Vertex AI",
@@ -136,6 +121,12 @@ api_providers = [
         api="openai_completions",
         options=LLMOptions(base_url="https://router.huggingface.co/v1"),
     ),
+    APIProvider(
+        id="subconscious",
+        name="Subconscious",
+        api="openai_completions",
+        options=LLMOptions(base_url="https://api.subconscious.dev/v1"),
+    ),
     APIProvider(id="mistral", name="Mistral", api="mistral_chat", options=LLMOptions()),
     APIProvider(
         id="ollama",

{tau_coding_agent-0.7.8 → tau_coding_agent-0.7.9}/tau/inference/api/text/service.py

@@ -283,15 +283,17 @@ class TextLLM:
         )
         from tau.inference.utils import ErrorKind, classify_error, get_retry_after_delay
 
+        api_key = await self._auth_manager.get_api_key(self.provider_id)  # type: ignore[union-attr]
+        if api_key:
+            # Set credentials before resolving the lazy adapter: SDK clients such as
+            # Anthropic validate and capture authentication during construction.
+            self.api.options.api_key = api_key
+
         # Resolve the provider SDK (first-use import + client construction) on a
         # worker thread so a cold import doesn't block the event loop — and with
         # it, the render loop's spinner animation.
         await self.api.resolve_async()
 
-        api_key = await self._auth_manager.get_api_key(self.provider_id)  # type: ignore[union-attr]
-        if api_key:
-            self.api.options.api_key = api_key
-
         messages = self._resolve_messages(context)
         api_context = LLMContext(
             messages=messages,
@@ -399,15 +401,16 @@ class TextLLM:
         from tau.inference.types import ErrorEvent, StopReason, ThinkingLevel
         from tau.inference.utils import ErrorKind, classify_error, get_retry_after_delay
 
+        api_key = await self._auth_manager.get_api_key(self.provider_id)  # type: ignore[union-attr]
+        if api_key:
+            # Set credentials before resolving the lazy adapter; see stream().
+            self.api.options.api_key = api_key
+
         # Resolve the provider SDK (first-use import + client construction) on a
         # worker thread so a cold import doesn't block the event loop — and with
         # it, the render loop's spinner animation.
         await self.api.resolve_async()
 
-        api_key = await self._auth_manager.get_api_key(self.provider_id)  # type: ignore[union-attr]
-        if api_key:
-            self.api.options.api_key = api_key
-
         original = self.api.options.thinking_level
         if thinking_level is not None and thinking_level != ThinkingLevel.Off:
             self.api.options.thinking_level = thinking_level

{tau_coding_agent-0.7.8 → tau_coding_agent-0.7.9}/tau/modes/interactive/agent_hooks.py

@@ -75,6 +75,16 @@ class AgentHookHandler:
         self._pending_flush_handle: asyncio.TimerHandle | None = None
         self._last_flush_at: float = 0.0
 
+        # Raw terminal/tool output arrives far more densely than model tokens
+        # (a chatty subprocess can emit hundreds of lines/sec — see
+        # runtime/service.py's per-line TerminalOutputEvent). Without batching,
+        # _on_terminal_output would invalidate() the block and force a full
+        # re-render on every single line, which is O(total output so far) each
+        # time and starves keystroke handling on the same event loop. Batched
+        # at the same ~60fps cadence as token streaming below.
+        self._pending_terminal_flush_handle: asyncio.TimerHandle | None = None
+        self._last_terminal_flush_at: float = 0.0
+
     def subscribe(self) -> None:
         """Register all hook handlers on the current agent."""
         agent = self._runtime.agent
@@ -105,6 +115,9 @@ class AgentHookHandler:
         if self._pending_flush_handle is not None:
             self._pending_flush_handle.cancel()
             self._pending_flush_handle = None
+        if self._pending_terminal_flush_handle is not None:
+            self._pending_terminal_flush_handle.cancel()
+            self._pending_terminal_flush_handle = None
         self._pending_msg = None
         self._current_block = None
         self._current_terminal_block = None
@@ -378,6 +391,13 @@ class AgentHookHandler:
             block = self._layout.add_message(msg, streaming=True)
             self._current_terminal_block = block
         else:
+            # Cancel any pending batched flush — this event supersedes it, and
+            # finalize() below is about to freeze the block for good, so a
+            # stale timer must not fire and invalidate() it afterward.
+            if self._pending_terminal_flush_handle is not None:
+                self._pending_terminal_flush_handle.cancel()
+                self._pending_terminal_flush_handle = None
+            self._last_terminal_flush_at = 0.0
             if self._current_terminal_block is not None:
                 self._current_terminal_block.set_streaming(False)
                 # Dropping our own reference for good right here — safe to
@@ -387,6 +407,30 @@ class AgentHookHandler:
         self._tui.request_render()
 
     async def _on_terminal_output(self, _event: object) -> None:
+        """Batch invalidation of the live terminal block at ~60fps.
+
+        Raw subprocess output can arrive far more densely than model tokens
+        (runtime/service.py emits a TerminalOutputEvent per line — a chatty
+        command can be hundreds/sec). invalidate()-ing and re-rendering on
+        every line forces a full re-parse of the whole accumulated output
+        each time (cost grows with total output so far), and that work runs
+        synchronously on the same event loop that reads keystrokes — see
+        TUI._on_stdin_ready — so unthrottled it directly steals time from
+        input responsiveness. Mirrors the token-flush batching above.
+        """
+        if self._current_terminal_block is None:
+            return
+        if self._pending_terminal_flush_handle is None:
+            elapsed = time.monotonic() - self._last_terminal_flush_at
+            delay = max(0.0, _STREAM_FLUSH_INTERVAL - elapsed)
+            loop = asyncio.get_event_loop()
+            self._pending_terminal_flush_handle = loop.call_later(
+                delay, self._flush_terminal_output
+            )
+
+    def _flush_terminal_output(self) -> None:
+        self._pending_terminal_flush_handle = None
+        self._last_terminal_flush_at = time.monotonic()
         if self._current_terminal_block is not None:
             self._current_terminal_block.invalidate()
             self._tui.request_render()
@@ -470,15 +514,24 @@ class AgentHookHandler:
         if self._current_block is None:
             return
         self._current_block._message = msg
+        if not streaming:
+            reset_streaming_md = getattr(
+                self._current_block,
+                "reset_streaming_markdown_cache",
+                None,
+            )
+            if callable(reset_streaming_md):
+                reset_streaming_md()
         self._current_block.set_streaming(streaming)
         self._current_block.invalidate()
         if clear:
-            # No finalize(): this is always an AssistantMessage/ToolMessage,
-            # a ctrl+o target — toggle_details_expanded only reaches
-            # still-live blocks, so freezing here the instant a reply
-            # finishes would make it permanently un-toggleable. It still
-            # freezes safely once something else is added after it (the
-            # "not last unit" fallback in render_split_cells).
+            # The driver is dropping its live reference to this block at true
+            # message completion.  Its content is now render-stable, so let
+            # MessageList freeze it immediately even if it is still the last
+            # unit.  This does not make ctrl+o/theme/session changes impossible:
+            # those paths explicitly invalidate frozen caches from the touched
+            # block and rebuild on demand.
+            self._current_block.finalize()
             self._current_block = None
             self._current_text_length = 0
 

{tau_coding_agent-0.7.8 → tau_coding_agent-0.7.9}/tau/modes/interactive/components/message_list.py

@@ -7,7 +7,7 @@ from tau.tui.buffer import Buffer
 from tau.tui.component import Component, StaticComponent
 from tau.tui.geometry import Rect
 from tau.tui.input import InputEvent, Key, KeyEvent, get_keybindings
-from tau.tui.markdown import render_markdown
+from tau.tui.markdown import StreamingMarkdownRenderer, render_markdown
 from tau.tui.style import Style, apply_style
 from tau.tui.theme import MessageTheme
 from tau.tui.utils import BOLD, RESET, _is_diff, cursor_block, visible_width, wrap
@@ -108,6 +108,10 @@ class MessageBlock:
         self._tool_results_cache: list[str] | None = None
         self._tool_results_message: object | None = None
         self._tool_results_width = 0
+        # Incremental markdown renderers for append-only streaming text/thinking
+        # content. They keep full streamed output visible while avoiding a full
+        # CommonMark parse of the whole growing response on every frame.
+        self._streaming_markdown: dict[tuple[int, bool], StreamingMarkdownRenderer] = {}
 
     # -------------------------------------------------------------------------
     # Public API
@@ -123,6 +127,13 @@ class MessageBlock:
         self._tool_results_cache = None
         self._tool_results_message = None
 
+    def reset_streaming_markdown_cache(self) -> None:
+        """Drop incremental markdown state for this block.
+
+        Used when a streamed message completes so the final render goes through
+        the normal whole-document path exactly once.
+        """
+        self._streaming_markdown.clear()
     def toggle_expanded(self) -> None:
         self._expanded = not self._expanded
         self.invalidate()
@@ -221,6 +232,33 @@ class MessageBlock:
     def message(self) -> object:
         return self._message
 
+    def _render_markdown_text(
+        self,
+        key: tuple[int, bool],
+        text: str,
+        width: int,
+        *,
+        preserve_soft_breaks: bool = False,
+    ) -> list[str]:
+        """Render markdown, using append-only incremental caching while streaming."""
+        if self._streaming:
+            renderer = self._streaming_markdown.get(key)
+            if renderer is None:
+                renderer = StreamingMarkdownRenderer()
+                self._streaming_markdown[key] = renderer
+            return renderer.render(
+                text,
+                width,
+                self._theme.markdown,
+                preserve_soft_breaks=preserve_soft_breaks,
+            )
+        return render_markdown(
+            text,
+            width,
+            self._theme.markdown,
+            preserve_soft_breaks=preserve_soft_breaks,
+        )
+
     # -------------------------------------------------------------------------
     # Rendering
     # -------------------------------------------------------------------------
@@ -407,10 +445,10 @@ class MessageBlock:
                     thinking_idx += 1
                 thinking_text = "".join(thinking_parts).rstrip()
                 thinking_lines = (
-                    render_markdown(
+                    self._render_markdown_text(
+                        (idx, True),
                         thinking_text,
                         inner_width,
-                        t.markdown,
                         preserve_soft_breaks=True,
                     )
                     if thinking_text
@@ -437,7 +475,11 @@ class MessageBlock:
                 lines.append("")
 
             elif isinstance(item, TextContent) and item.content:
-                for line in render_markdown(item.content.rstrip(), inner_width, t.markdown):
+                for line in self._render_markdown_text(
+                    (idx, False),
+                    item.content.rstrip(),
+                    inner_width,
+                ):
                     lines.append("  " + line)
 
             elif isinstance(item, _ImageContent):
@@ -960,13 +1002,19 @@ class MessageList(Component):
         this should rarely trigger. If it ever does (e.g. a render happened
         to land between adding a block and an immediate undo), resetting here
         forces one full rebuild rather than leaving the cache pointing past
-        the end of self._blocks.
+        the end of self._blocks. Must bump frozen_generation too — its
+        contract (see the field's docstring) is "bumped every time
+        _frozen_buf is rebuilt from scratch", and callers like
+        TUI.render_cells cache pre-widened frozen rows keyed on this counter;
+        resetting _frozen_buf without it would let that cache keep serving
+        now-stale content for a unit that no longer exists.
         """
         if self._frozen_block_count > len(self._blocks):
             self._frozen_buf = None
             self._frozen_block_count = 0
             self._frozen_unit_ends = []
             self._frozen_unit_rows = []
+            self.frozen_generation += 1
 
     def remove_last(self) -> bool:
         """Remove the last block (used to undo a user message on pre-stream abort)."""
@@ -1003,6 +1051,11 @@ class MessageList(Component):
         self._frozen_block_count = 0
         self._frozen_unit_ends = []
         self._frozen_unit_rows = []
+        # See _guard_frozen_bounds: any reset of _frozen_buf must bump this so
+        # callers caching pre-widened frozen rows keyed on it (TUI.render_cells)
+        # drop their now-stale cache instead of continuing to serve rows from
+        # the conversation that was just cleared.
+        self.frozen_generation += 1
 
     def add_message(self, message: object, streaming: bool = False) -> MessageBlock:
         block = MessageBlock(

{tau_coding_agent-0.7.8 → tau_coding_agent-0.7.9}/tau/tui/markdown.py

@@ -200,15 +200,136 @@ def render_markdown(
     preserve_soft_breaks: bool = False,
 ) -> list[str]:
     """Render a markdown string to a list of ANSI-coloured terminal lines."""
+    return _render_markdown(text, width, theme, preserve_soft_breaks=preserve_soft_breaks)
+
+
+def _render_markdown(
+    text: str,
+    width: int,
+    theme: MarkdownTheme,
+    *,
+    preserve_soft_breaks: bool = False,
+    trim_trailing_blank_lines: bool = True,
+) -> list[str]:
     document, html_block, html_span, md_context = _mistletoe()
     with md_context(html_span, html_block):
         doc = document(text.splitlines(keepends=True))
         lines = _Renderer(width, theme, preserve_soft_breaks).render_blocks(doc.children or [])
-    while lines and lines[-1] == "":
-        lines.pop()
+    if trim_trailing_blank_lines:
+        while lines and lines[-1] == "":
+            lines.pop()
     return lines
 
 
+class StreamingMarkdownRenderer:
+    """Incremental renderer for append-only streamed markdown.
+
+    A normal ``render_markdown(growing_text, ...)`` call reparses the entire
+    CommonMark document every frame.  For long streamed replies that becomes
+    O(total_response_size) on the UI event loop and can delay keystroke echo.
+
+    This cache freezes complete top-level block groups once a blank-line
+    boundary has moved behind the live tail, then reparses only the still-open
+    suffix on subsequent frames.  The final non-streaming render should still
+    call ``render_markdown`` once for exact whole-document semantics.
+    """
+
+    def __init__(self) -> None:
+        self._width = -1
+        self._theme_id = 0
+        self._preserve_soft_breaks = False
+        self._text = ""
+        self._frozen_until = 0
+        self._frozen_lines: list[str] = []
+
+    def reset(self) -> None:
+        self._text = ""
+        self._frozen_until = 0
+        self._frozen_lines = []
+
+    def render(
+        self,
+        text: str,
+        width: int,
+        theme: MarkdownTheme,
+        *,
+        preserve_soft_breaks: bool = False,
+    ) -> list[str]:
+        theme_id = id(theme)
+        if (
+            width != self._width
+            or theme_id != self._theme_id
+            or preserve_soft_breaks != self._preserve_soft_breaks
+            or not text.startswith(self._text)
+        ):
+            self._width = width
+            self._theme_id = theme_id
+            self._preserve_soft_breaks = preserve_soft_breaks
+            self.reset()
+
+        self._text = text
+        freeze_until = _streaming_markdown_freeze_cutoff(text)
+        if freeze_until > self._frozen_until:
+            newly_stable = text[self._frozen_until:freeze_until]
+            rendered = _render_markdown(
+                newly_stable,
+                width,
+                theme,
+                preserve_soft_breaks=preserve_soft_breaks,
+            )
+            if rendered:
+                if self._frozen_lines and self._frozen_lines[-1] != "":
+                    self._frozen_lines.append("")
+                self._frozen_lines.extend(rendered)
+                # Preserve the block separator represented by the stable blank
+                # boundary; render_markdown trims it for full-document display.
+                if self._frozen_lines[-1] != "":
+                    self._frozen_lines.append("")
+            self._frozen_until = freeze_until
+
+        tail = text[self._frozen_until :]
+        tail_lines = _render_markdown(
+            tail,
+            width,
+            theme,
+            preserve_soft_breaks=preserve_soft_breaks,
+        )
+        if not tail_lines:
+            frozen = self._frozen_lines
+            return list(frozen[:-1] if frozen[-1:] == [""] else frozen)
+        return [*self._frozen_lines, *tail_lines]
+
+
+def _streaming_markdown_freeze_cutoff(text: str) -> int:
+    """Return an append-only cutoff for completed top-level markdown blocks.
+
+    During streaming, only the current open block needs to remain live.  Once a
+    blank-line boundary is seen outside a fenced code block, the block before
+    that boundary is structurally complete for the common assistant-output cases
+    we render here (paragraphs, headings, lists, tables, quotes, fenced code).
+    Freezing up to the latest such boundary keeps active streaming work bounded
+    to the current block instead of the whole reply.
+    """
+    boundaries: list[int] = []
+    in_fence = False
+    fence_marker = ""
+    pos = 0
+    for line in text.splitlines(keepends=True):
+        stripped = line.strip()
+        if stripped.startswith(("```", "~~~")):
+            marker = stripped[:3]
+            if not in_fence:
+                in_fence = True
+                fence_marker = marker
+            elif marker == fence_marker:
+                in_fence = False
+                fence_marker = ""
+        pos += len(line)
+        if not in_fence and stripped == "":
+            boundaries.append(pos)
+    return boundaries[-1] if boundaries else 0
+
+
 # ── Renderer ──────────────────────────────────────────────────────────────────