tau-coding-agent 0.2.0__tar.gz → 0.3.1__tar.gz

{tau_coding_agent-0.2.0/tau_coding_agent.egg-info → tau_coding_agent-0.3.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.2.0
+Version: 0.3.1
 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.13.*
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: anthropic==0.109.1
@@ -25,6 +25,7 @@ Requires-Dist: pyyaml==6.0.2
 Requires-Dist: pygments==2.20.0
 Requires-Dist: pathspec==1.1.1
 Requires-Dist: gitpython==3.1.50
+Requires-Dist: grapheme==0.6.0
 Dynamic: license-file
 
 # Tau (τ)

{tau_coding_agent-0.2.0 → tau_coding_agent-0.3.1}/docs/architecture.md

@@ -161,7 +161,7 @@ Before each inference call, the runtime builds the context:
 8. Count tokens
 ```
 
-If tokens exceed the model's context window, automatic compaction summarizes older messages.
+Automatic compaction summarizes older messages when context approaches the limit. It is checked before sending a turn (pre-flight) and after each turn, and — as a reactive backstop — a request that still fails with a provider context-overflow error triggers a compact-and-retry (bounded to one attempt). See [Context Compaction](sessions.md#context-compaction).
 
 ## Hook & Event System
 

{tau_coding_agent-0.2.0 → tau_coding_agent-0.3.1}/docs/extensions.md

@@ -200,6 +200,7 @@ def register(tau):
 | `ctx.cwd` | `Path` | Working directory |
 | `ctx.model_id` | `str` | Active model, e.g. `"claude-sonnet-4-6"` |
 | `ctx.provider_id` | `str` | Active provider, e.g. `"anthropic"` |
+| `ctx.llm` | `TextLLM \| None` | Active text LLM for running your own model calls (`await ctx.llm.invoke(LLMContext(...))`); `None` outside a live session |
 | `ctx.settings` | `SettingsManager \| None` | Full settings access |
 | `ctx.mode` | `str` | `"tui"` when running in the interactive terminal, `"headless"` otherwise |
 | `ctx.has_ui` | `bool` | True when dialog-capable UI is available — guards TUI-only calls |
@@ -459,7 +460,7 @@ the default algorithm runs.
 ### Example — use a different model for summarisation
 
 ```python
-from tau.hooks.types import BeforeCompactionResult
+from tau.hooks import BeforeCompactionResult
 from tau.session.compaction import CompactionResult
 
 def register(tau):
@@ -489,7 +490,7 @@ def register(tau):
 ### Example — block automatic compaction
 
 ```python
-from tau.hooks.types import BeforeCompactionResult
+from tau.hooks import BeforeCompactionResult
 
 def register(tau):
     @tau.on("before_compaction")

{tau_coding_agent-0.2.0 → tau_coding_agent-0.3.1}/docs/sessions.md

@@ -246,10 +246,22 @@ Long sessions eventually fill the model's context window. Tau handles this autom
 
 ### How It Works
 
-1. **Auto-trigger** — after each agent turn, Tau estimates the current token usage. If `context_tokens > context_window - reserve_tokens`, compaction runs automatically.
-2. **Cut-point detection** — Tau walks backwards from the most recent message, accumulating token estimates, until it has identified the `keep_recent_tokens` worth of messages to preserve. It never cuts in the middle of a tool call/result pair.
-3. **Summarisation** — the messages before the cut point are sent to the model with a summarisation prompt. The resulting summary is stored in the session file as a `compaction` entry and prepended to the context on the next turn.
-4. **Iterative merging** — if compaction has happened before, the new summary prompt includes the previous summary so history is never lost.
+1. **Cut-point detection** — Tau walks backwards from the most recent message, accumulating token estimates, until it has identified the `keep_recent_tokens` worth of messages to preserve. It never cuts in the middle of a tool call/result pair; if the cut would land inside a turn, the turn's prefix is summarised separately.
+2. **Summarisation** — the messages before the cut point are sent to the model with a structured summarisation prompt (Goal / Progress / Decisions / Next Steps / Critical Context). The resulting summary is stored in the session file as a `compaction` entry and prepended to the context (wrapped in `<context-summary>` tags) on the next turn.
+3. **Iterative merging** — if compaction has happened before, the new summary prompt includes the previous summary so history is never lost.
+
+### When Compaction Runs
+
+Token usage is estimated from the **last successful response's reported usage** plus a chars/4 estimate of anything after it, so the trigger reflects real provider accounting rather than a pure guess. The threshold is `context_tokens > context_window - reserve_tokens`. Tau checks this at three points so context is trimmed before it can overflow:
+
+1. **Pre-flight** — before sending a new turn. Catches resumed or already-oversized sessions that would otherwise fail on the very first request.
+2. **Post-turn** — after each agent turn completes, the normal proactive path.
+3. **Overflow recovery (reactive backstop)** — if a request still fails with a provider *context-overflow* error, Tau catches it, drops the failed response, compacts, and **retries the turn once** automatically. This is bounded to a single attempt per turn — if it overflows again, Tau surfaces a message asking you to reduce context or switch to a larger-context model rather than looping.
+
+Two guards keep this stable:
+
+- **Stale-anchor guard** — immediately after a compaction, the kept messages still carry their pre-compaction (large) usage numbers. Tau skips re-triggering when the usage anchor predates the latest compaction, so it won't compact on every subsequent turn.
+- **Circuit breaker** — if automatic compaction fails repeatedly (3×), Tau stops auto-compacting for the session and surfaces a notice instead of failing silently. You can still run `/compact` manually.
 
 ### Manual Compaction
 

{tau_coding_agent-0.2.0 → tau_coding_agent-0.3.1}/docs/themes.md

@@ -73,6 +73,34 @@ The `name` field in the file determines the theme name used in settings and `--t
 
 > **Formats**: `.yaml` and `.yml` are recommended. `.json` is also accepted for backwards compatibility.
 
+### Color values
+
+Every color token accepts three forms, and you can mix them freely in one theme:
+
+| Form | Example | Renders as |
+|------|---------|------------|
+| **Hex** (24-bit truecolor) | `"#a78bfa"` | exact RGB, identical on every terminal |
+| **Named ANSI** | `bright_cyan` | the terminal's own palette color (adapts to the user's terminal theme) |
+| **With attributes** | `{ color: "#a78bfa", bold: true, italic: true, dim: true }` | either hex or named, plus styling |
+
+Valid names: `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`, `default`, and their `bright_` variants (e.g. `bright_black`).
+
+**Which to use?**
+- **Named ANSI** for a theme that should *blend into the user's terminal* (the built-in `dark` theme uses these, so its colors match whatever palette the user has set). Best for a default/adaptive theme.
+- **Hex** for a theme with an *exact, branded look* that should appear the same on every machine (the built-in `light` theme uses hex). Best for a distinctive, designed theme.
+
+An unrecognized value (a typo, or malformed hex like `#fff`) silently falls back to that token's built-in default rather than erroring. Hex must be full `#rrggbb`.
+
+### Syntax highlighting
+
+Fenced code blocks are syntax-highlighted with [Pygments](https://pygments.org/styles/). Choose the style with a top-level `code_syntax_style` key:
+
+```yaml
+code_syntax_style: monokai   # any Pygments style name; "" disables highlighting
+```
+
+Pick a dark style (`monokai`, `dracula`, `nord`, `gruvbox-dark`, …) for dark themes and a light style (`friendly`, `default`, `xcode`, `solarized-light`, …) for light backgrounds. Setting it to `""` falls back to the flat `code_block` color.
+
 ### Theme YAML format
 
 ```yaml
@@ -82,8 +110,11 @@ name: my_theme
 show_thinking:   true   # show/hide the model's thinking blocks
 show_tool_calls: true   # show/hide tool call output
 
+# Syntax highlighting for fenced code blocks (Pygments style; "" to disable)
+code_syntax_style: monokai
+
 colors:
-  # UI chrome
+  # UI chrome — hex for exact colors, or names like `bright_black` to use the terminal palette
   divider:           "#374151"
   spinner_frame:     "#0ea5e9"
   spinner_label:     "#6b7280"

{tau_coding_agent-0.2.0 → tau_coding_agent-0.3.1}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.2.0"
+version = "0.3.1"
 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.13.*"
+requires-python = ">=3.12"
 dependencies = [
     "anthropic==0.109.1",
     "certifi==2026.5.20",
@@ -29,6 +29,7 @@ dependencies = [
     "pygments==2.20.0",
     "pathspec==1.1.1",
     "gitpython==3.1.50",
+    "grapheme==0.6.0",
 ]
 
 [project.scripts]
@@ -40,7 +41,7 @@ tau = "tau.console.cli:main"
 resolution = "highest"
 
 [tool.ruff]
-target-version = "py313"
+target-version = "py312"
 line-length = 100
 
 [tool.ruff.lint]

{tau_coding_agent-0.2.0 → tau_coding_agent-0.3.1}/tau/agent/service.py

@@ -77,6 +77,7 @@ class Agent:
         self._phase: AgentPhase = AgentPhase.IDLE
         self._signal: asyncio.Event = asyncio.Event()
         self._compaction_failures: int = 0
+        self._overflow_recovery_attempted: bool = False
         self._engine.options.before_tool_call = self._before_tool_call
         self._engine.options.after_tool_call = self._after_tool_call
 
@@ -208,12 +209,25 @@ class Agent:
     async def compact(self, custom_instructions: str | None = None) -> bool:
         """Manually trigger context compaction. Returns True if compaction ran."""
         from tau.session.compaction import prepare_compaction
-        from tau.hooks.engine import CompactionEndEvent
         entries = self._session_manager.get_branch()
         preparation = prepare_compaction(entries, self._config.compaction)
         if preparation is None:
             return False
-        result, from_extension = await self._run_compaction(preparation, entries, manual=True, custom_instructions=custom_instructions)
+        await self._apply_compaction(preparation, entries, manual=True, custom_instructions=custom_instructions)
+        return True
+
+    async def _apply_compaction(
+        self,
+        preparation: "CompactionPreparation",
+        entries: list,
+        manual: bool,
+        custom_instructions: str | None = None,
+    ) -> None:
+        """Run a prepared compaction, persist the summary, and emit the end event."""
+        from tau.hooks.engine import CompactionEndEvent
+        result, from_extension = await self._run_compaction(
+            preparation, entries, manual=manual, custom_instructions=custom_instructions
+        )
         self._session_manager.append_compaction(
             summary=result.summary,
             first_kept_entry_id=result.first_kept_entry_id,
@@ -221,12 +235,19 @@ class Agent:
         )
         self._compaction_failures = 0
         await self.hooks.emit(CompactionEndEvent(
-            manual=True,
+            manual=manual,
             tokens_before=result.tokens_before,
             summary_length=len(result.summary),
             from_extension=from_extension,
         ))
-        return True
+
+    def _latest_compaction_timestamp(self) -> float | None:
+        """Timestamp of the most recent compaction in the active branch, if any."""
+        from tau.session.types import CompactionEntry
+        for entry in reversed(self._session_manager.get_branch()):
+            if isinstance(entry, CompactionEntry):
+                return entry.timestamp
+        return None
 
     async def _check_compaction(self) -> None:
         """Auto-compact if context usage exceeds the threshold. Circuit-breaks after 3 failures."""
@@ -234,7 +255,6 @@ class Agent:
             estimate_context_tokens, should_compact,
             prepare_compaction,
         )
-        from tau.hooks.engine import CompactionEndEvent
 
         if self._compaction_failures >= 3:
             return
@@ -248,29 +268,99 @@ class Agent:
         llm_messages = _to_llm_messages(session_ctx.messages)
 
         usage = estimate_context_tokens(llm_messages)
-        if not should_compact(usage.tokens, self._context_window, settings):
-            return
+
+        # "Silent" overflow: some providers accept an over-limit prompt and return a
+        # successful response (z.ai) or truncate the input and stop with no output
+        # (Xiaomi MiMo) instead of erroring. The threshold check can miss these, so
+        # force compaction when the last response shows the symptom.
+        last = self._session_manager.find_last_assistant_message()
+        forced = last is not None and self._is_silent_overflow(last)
+
+        if not forced:
+            if not should_compact(usage.tokens, self._context_window, settings):
+                return
+            # Stale-anchor guard: right after a compaction the kept messages still carry
+            # pre-compaction usage on their anchor, which would re-trigger compaction every
+            # turn. Skip if the usage anchor predates the latest compaction boundary.
+            if usage.last_usage_index is not None:
+                anchor = llm_messages[usage.last_usage_index]
+                comp_ts = self._latest_compaction_timestamp()
+                if comp_ts is not None and getattr(anchor, "timestamp", 0.0) <= comp_ts:
+                    return
 
         preparation = prepare_compaction(entries, settings)
         if preparation is None:
             return
 
         try:
-            result, from_extension = await self._run_compaction(preparation, entries, manual=False)
-            self._session_manager.append_compaction(
-                summary=result.summary,
-                first_kept_entry_id=result.first_kept_entry_id,
-                tokens_before=result.tokens_before,
+            await self._apply_compaction(preparation, entries, manual=False)
+        except Exception:
+            self._compaction_failures += 1
+
+    def _is_silent_overflow(self, message: AssistantMessage) -> bool:
+        """Detect overflow on a *successful* response (no error was raised).
+
+        - Silent (z.ai): a normal stop whose input tokens exceed the window.
+        - Length-stop (Xiaomi MiMo): server truncated the input to fill the window,
+          leaving no room to generate, so it stops with zero output.
+        """
+        from tau.inference.types import StopReason
+        cw = self._context_window
+        if cw <= 0:
+            return False
+        u = message.usage
+        inp = u.input_tokens + u.cache_read_tokens
+        if message.stop_reason == StopReason.Stop and inp > cw:
+            return True
+        if message.stop_reason == StopReason.Length and u.output_tokens == 0 and inp >= cw * 0.99:
+            return True
+        return False
+
+    async def _try_overflow_recovery(self) -> bool:
+        """If the last turn died with a context-overflow error, compact once and signal a retry.
+
+        Drops the error message so it isn't kept or used as a stale anchor, compacts the
+        history, and lets the caller re-run the turn. Bounded to one attempt per turn so a
+        session that overflows even after compaction fails cleanly.
+        """
+        from tau.inference.utils import ErrorKind
+        from tau.session.compaction import prepare_compaction
+
+        last = self._session_manager.find_last_assistant_message()
+        if last is None or last.error_kind != ErrorKind.CONTEXT_OVERFLOW:
+            return False
+
+        if self._overflow_recovery_attempted:
+            self._notify(
+                "Context overflow recovery failed after compaction. "
+                "Reduce context or switch to a larger-context model."
             )
-            self._compaction_failures = 0
-            await self.hooks.emit(CompactionEndEvent(
-                manual=False,
-                tokens_before=result.tokens_before,
-                summary_length=len(result.summary),
-                from_extension=from_extension,
-            ))
+            return False
+        self._overflow_recovery_attempted = True
+
+        # Drop the error assistant message — it has no usable content and would otherwise
+        # anchor stale usage / be re-sent on retry.
+        self._session_manager.remove_last_message()
+
+        entries = self._session_manager.get_branch()
+        preparation = prepare_compaction(entries, self._config.compaction)
+        if preparation is None:
+            return False
+        try:
+            await self._apply_compaction(preparation, entries, manual=False)
         except Exception:
             self._compaction_failures += 1
+            return False
+        return True
+
+    def _notify(self, message: str) -> None:
+        """Surface a message to the UI if a runtime/UI is wired up."""
+        if self._runtime is None:
+            return
+        from tau.extensions.context import ExtensionContext
+        ctx = ExtensionContext.from_runtime(self._runtime)
+        if ctx.ui is not None:
+            ctx.ui.notify(message)
 
     async def _run_compaction(self, preparation: "CompactionPreparation", entries: list, manual: bool, custom_instructions: str | None = None) -> tuple:
         """Emit before_compaction (allowing interception), then run the default algorithm.
@@ -281,7 +371,7 @@ class Agent:
         consistent with error-fallthrough behaviour.
         """
         from tau.session.compaction import compact as _compact
-        from tau.hooks.types import BeforeCompactionEvent, BeforeCompactionResult, CompactionStartEvent
+        from tau.hooks.engine import BeforeCompactionEvent, BeforeCompactionResult, CompactionStartEvent
 
         before_results = await self.hooks.emit(BeforeCompactionEvent(
             preparation=preparation,
@@ -312,33 +402,33 @@ class Agent:
 
         opts = options or PromptOptions()
 
-        session_ctx = self._session_manager.build_session_context()
-        llm_messages = _to_llm_messages(session_ctx.messages)
-        llm_messages = strip_unusable_trailing_assistant(llm_messages, self._session_manager)
-
-        if opts.images:
-            user_message = UserMessage.with_images(text, list(opts.images))
-        elif opts.audio:
-            user_message = UserMessage.with_audio(text, list(opts.audio))
-        elif opts.video:
-            user_message = UserMessage.with_video(text, list(opts.video))
-        else:
-            user_message = UserMessage.from_text(text)
-        self._session_manager.append_message(user_message, meta=opts.meta)
-        llm_messages.append(user_message)
+        # Pre-flight: a resumed or already-oversized session can exceed the window on the
+        # very first send. Compact before appending and shipping the new turn.
+        await self._check_compaction()
 
-        ctx = AgentContext(
-            system_prompt=self._system_prompt,
-            messages=llm_messages,
-            tools=self._engine.tools,
+        user_message = UserMessage.with_media(
+            text,
+            list(opts.images) if opts.images else None,
+            list(opts.audio) if opts.audio else None,
+            list(opts.video) if opts.video else None,
         )
+        self._session_manager.append_message(user_message, meta=opts.meta)
 
-        self._signal = asyncio.Event()
-        self._engine.llm.api.options.signal = self._signal
-
+        self._overflow_recovery_attempted = False
         self._phase = AgentPhase.TURN
         try:
-            await self._run(ctx)
+            while True:
+                ctx = self._build_turn_context()
+                self._signal = asyncio.Event()
+                self._engine.llm.api.options.signal = self._signal
+                try:
+                    await self._run(ctx)
+                    break
+                except RuntimeError:
+                    # On a context-overflow error, compact and retry the turn once.
+                    if await self._try_overflow_recovery():
+                        continue
+                    raise
         finally:
             self._phase = AgentPhase.IDLE
 
@@ -349,6 +439,17 @@ class Agent:
         if not self._engine.has_pending_messages():
             await self.hooks.emit(SettledEvent())
 
+    def _build_turn_context(self) -> AgentContext:
+        """Build the LLM context for a turn from the current (possibly compacted) session."""
+        session_ctx = self._session_manager.build_session_context()
+        llm_messages = _to_llm_messages(session_ctx.messages)
+        llm_messages = strip_unusable_trailing_assistant(llm_messages, self._session_manager)
+        return AgentContext(
+            system_prompt=self._system_prompt,
+            messages=llm_messages,
+            tools=self._engine.tools,
+        )
+
     async def _run(self, ctx: AgentContext) -> None:
         unsubscribe = self.hooks.register(
             'message_end',

{tau_coding_agent-0.2.0 → tau_coding_agent-0.3.1}/tau/auth/manager.py

@@ -16,6 +16,28 @@ def _get_env_api_key(provider: str) -> str | None:
     return os.environ.get(f"{provider.upper()}_API_KEY")
 
 
+def _is_unrecoverable_refresh_error(error: Exception) -> bool:
+    """Return True when a failed token refresh means the refresh token itself is
+    dead (so the user must log in again), rather than a transient network/5xx blip.
+
+    Defers to the shared inference error classifier for the cases it understands
+    (auth → unrecoverable; rate-limit/overloaded/server/timeout → transient). OAuth
+    token endpoints, however, report a dead refresh token as ``invalid_grant`` /
+    HTTP 400 — which the inference-oriented classifier leaves as UNKNOWN — and the
+    provider wrappers raise these as ``RuntimeError("Request failed (<code>): ...")``
+    without a status_code attribute, so we match those markers explicitly.
+    """
+    from tau.inference.utils import classify_error, ErrorKind
+
+    kind = classify_error(error).kind
+    if kind in (ErrorKind.AUTH, ErrorKind.AUTH_PERMANENT):
+        return True
+    if kind in (ErrorKind.RATE_LIMIT, ErrorKind.OVERLOADED, ErrorKind.SERVER_ERROR, ErrorKind.TIMEOUT):
+        return False
+    text = str(error).lower()
+    return any(m in text for m in ("invalid_grant", "invalid_request", "invalid_token", "(400)", "(401)", "(403)"))
+
+
 class AuthManager:
     """Credential storage with pluggable backends."""
 
@@ -231,6 +253,66 @@ class AuthManager:
         result = await self.storage.with_lock_async(refresh_fn)
         return result.result
 
+    def is_oauth(self, provider: str) -> bool:
+        """Return True if the stored credential for a provider is an OAuth credential."""
+        return isinstance(self.get(provider), OAuthCredential)
+
+    async def force_refresh(self, provider: str, stale_access: str | None = None) -> OAuthCredential | None:
+        """Force-refresh an OAuth credential whose access token was rejected (e.g. a
+        mid-request 401) even though it is not yet time-expired.
+
+        Returns the new credential on success. Returns None if the provider isn't
+        OAuth or the refresh failed; on an *unrecoverable* failure (dead refresh
+        token) the stored credential is removed so the caller can prompt re-login,
+        whereas a transient failure leaves it untouched.
+
+        ``stale_access`` is the access token that was just rejected: if another
+        instance has already refreshed it under the lock, we adopt that result
+        instead of rotating the refresh token a second time.
+        """
+        oauth_provider = self.registry.text.get_oauth_provider(provider=provider)
+        if not oauth_provider:
+            return None
+
+        async def refresh_fn(current: str | None) -> LockResult:
+            """Refresh (unconditionally) the OAuth token in storage under the lock."""
+            current_data = self._parse_storage_data(current)
+            credential = current_data.get(provider)
+
+            if not isinstance(credential, OAuthCredential):
+                return LockResult(result=None)
+
+            # Another instance already refreshed after our token was rejected.
+            if stale_access is not None and credential.access != stale_access:
+                self.data = current_data
+                return LockResult(result=credential)
+
+            try:
+                refreshed_credential = await oauth_provider.refresh_token(credential=credential)
+                if credential.extra:
+                    merged_extra = dict(credential.extra)
+                    merged_extra.update(refreshed_credential.extra)
+                    refreshed_credential.extra = merged_extra
+                current_data[provider] = refreshed_credential
+                self.data = current_data
+                serialized = {k: self._serialize_credential(v) for k, v in current_data.items()}
+                return LockResult(result=refreshed_credential, next=json.dumps(serialized, indent=2))
+            except Exception as e:
+                self._record_error(e)
+                if _is_unrecoverable_refresh_error(e):
+                    # Refresh token is dead — drop the credential so the user is
+                    # prompted to log in again rather than retrying a broken token.
+                    current_data.pop(provider, None)
+                    self.data = current_data
+                    serialized = {k: self._serialize_credential(v) for k, v in current_data.items()}
+                    return LockResult(result=None, next=json.dumps(serialized, indent=2))
+                # Transient failure — keep the credential for a later retry.
+                self.data = current_data
+                return LockResult(result=None)
+
+        result = await self.storage.with_lock_async(refresh_fn)
+        return result.result
+
     async def login(self, provider: str, callbacks: OAuthLoginCallbacks):
         """Perform OAuth login flow for a provider and store the resulting credential."""
         if oauth_provider := self.registry.text.get_oauth_provider(provider):

tau_coding_agent-0.3.1/tau/builtins/themes/dark.yaml

@@ -0,0 +1,50 @@
+name: dark
+
+# The default theme. Colours use named ANSI values (not hex), so they map to the
+# terminal's own 16-colour palette and adapt to the user's terminal theme.
+# Per-token bold/italic is applied by the loader, so only the colour is listed here.
+# Purely structural tokens (bold/italic/strikethrough/dim/reverse, the plain
+# "tool result", spinner label) carry no colour and inherit the code defaults.
+
+# Pygments style for fenced code blocks (dark background).
+code_syntax_style: monokai
+
+colors:
+  # Chrome
+  divider:            bright_black
+
+  # Spinner
+  spinner_frame:      bright_cyan
+
+  # Markdown
+  heading:            bright_cyan
+  code_inline:        bright_yellow
+  code_block:         bright_green
+  code_block_border:  bright_black
+  quote_border:       bright_black
+  hr:                 bright_black
+  list_bullet:        bright_cyan
+  link_text:          bright_cyan
+  link_url:           bright_black
+
+  # Messages
+  you_label:          bright_cyan
+  assistant_label:    bright_green
+  tool_arrow:         bright_yellow
+  tool_result_err:    bright_red
+  error_label:        bright_red
+  stream_cursor:      bright_white
+
+  # Diffs
+  diff_added:         bright_green
+  diff_removed:       bright_red
+  diff_context:       bright_black
+  diff_hunk:          bright_yellow
+
+  # Select list / palette
+  selected_label:     bright_white
+  selected_desc:      bright_black
+  normal_label:       bright_black
+  normal_desc:        bright_black
+  indicator:          bright_black
+  empty:              bright_black

{tau_coding_agent-0.2.0 → tau_coding_agent-0.3.1}/tau/builtins/themes/light.yaml

@@ -1,5 +1,8 @@
 name: light
 
+# Light-background syntax style for fenced code blocks (pygments style name).
+code_syntax_style: friendly
+
 colors:
   # UI chrome
   divider:          "#c8c8c8"

{tau_coding_agent-0.2.0 → tau_coding_agent-0.3.1}/tau/console/cli.py

@@ -36,7 +36,6 @@ def resolve_model(model: str | None, provider: str | None) -> tuple[str | None,
 
 
 @click.group(invoke_without_command=True, context_settings={"help_option_names": ["-h", "--help"]})
-@click.argument("message", required=False, default=None)
 @click.option("--version", "-v", is_flag=True, default=False, help="Print version and exit.")
 @click.option("--debug", "-d", is_flag=True, default=False, help="Enable debug logging.")
 @click.option("--cwd", "-c", default=None, metavar="PATH", help="Set the working directory.")
@@ -71,7 +70,6 @@ def resolve_model(model: str | None, provider: str | None) -> tuple[str | None,
 @click.pass_context
 def cli(
     ctx: click.Context,
-    message: str | None,
     version: bool,
     debug: bool,
     cwd: str | None,
@@ -103,7 +101,7 @@ def cli(
         os.chdir(cwd)
 
     ctx.ensure_object(dict)
-    ctx.obj["message"] = prompt or message
+    ctx.obj["prompt"] = prompt
     ctx.obj["provider"] = provider
     ctx.obj["model"] = model
     ctx.obj["theme"] = theme
@@ -156,9 +154,9 @@ async def _start(opts: dict) -> None:
             case "interactive":
                 await _run_interactive(runtime, opts["theme"])
             case "print":
-                await _run_print(runtime, opts["message"], quiet=opts.get("quiet", False))
+                await _run_print(runtime, opts["prompt"], quiet=opts.get("quiet", False))
             case "json":
-                await _run_json(runtime, opts["message"], quiet=opts.get("quiet", False))
+                await _run_json(runtime, opts["prompt"], quiet=opts.get("quiet", False))
             case "rpc":
                 from tau.rpc.mode import run_rpc_mode
                 await run_rpc_mode(runtime)

{tau_coding_agent-0.2.0 → tau_coding_agent-0.3.1}/tau/engine/service.py

@@ -564,9 +564,10 @@ class Engine:
                                     _streaming_thinking = None
                                 else:
                                     message.contents.append(thinking)
-                            case ErrorEvent(reason=reason, error=error):
+                            case ErrorEvent(reason=reason, error=error, kind=kind):
                                 message.stop_reason = reason
                                 message.error = error
+                                message.error_kind = kind
                             case EndEvent() as ev:
                                 message.stop_reason = ev.reason
                                 message.usage = Usage(