tau-coding-agent 0.3.5__tar.gz → 0.3.9__tar.gz

{tau_coding_agent-0.3.5/tau_coding_agent.egg-info → tau_coding_agent-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.3.5
+Version: 0.3.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
@@ -26,6 +26,8 @@ Requires-Dist: pygments==2.20.0
 Requires-Dist: pathspec==1.1.1
 Requires-Dist: gitpython==3.1.50
 Requires-Dist: grapheme==0.6.0
+Provides-Extra: tools
+Requires-Dist: ripgrep>=14.0.0; extra == "tools"
 Dynamic: license-file
 
 # Tau (τ)

{tau_coding_agent-0.3.5 → tau_coding_agent-0.3.9}/docs/auth.md

@@ -143,6 +143,7 @@ The provider ID used as the key in `auth.json` and the `{PROVIDER}_API_KEY` env
 | OpenAI | `openai` | `OPENAI_API_KEY` |
 | Google | `google` | `GOOGLE_API_KEY` |
 | Mistral | `mistral` | `MISTRAL_API_KEY` |
+| Fireworks AI | `fireworks` | `FIREWORKS_API_KEY` |
 | Ollama | `ollama` | `OLLAMA_API_KEY` |
 
 ## Next Steps

{tau_coding_agent-0.3.5 → tau_coding_agent-0.3.9}/docs/extensions.md

@@ -627,29 +627,6 @@ session working directory; pass an explicit `cwd=` to override.
 
 ---
 
-## Cross-extension event bus
-
-Extensions can communicate with each other via `tau.events`:
-
-```python
-# producer.py
-def register(tau):
-    @tau.on("session_start")
-    async def on_start(event, ctx):
-        await tau.events.emit("producer:ready", {"version": "1.0"})
-
-# consumer.py
-def register(tau):
-    @tau.events.on("producer:ready")
-    async def on_ready(data):
-        print(f"producer ready — version {data['version']}")
-```
-
-This is separate from the hooks bus: `tau.events` is for extension-to-extension
-messages; `tau.on(...)` is for system lifecycle events.
-
----
-
 ## Editor autocomplete providers
 
 Extensions can inject custom autocomplete suggestions into the editor. When the user
@@ -742,7 +719,6 @@ def register(tau):
 | `tau.register_flag(name, type, env, default)` | Declare an env-backed flag |
 | `tau.get_flag(name)` | Read a registered flag's value |
 | `await tau.exec(cmd, args, cwd)` | Run a shell command |
-| `tau.events` | Cross-extension `EventBus` |
 | `tau.config` | Per-extension settings dict from `settings.json` |
 | `tau.cwd` | `Path` — working directory at session start |
 | `tau.model_id` | Active model identifier |

{tau_coding_agent-0.3.5 → tau_coding_agent-0.3.9}/docs/inference-providers.md

@@ -12,6 +12,7 @@ Tau supports the following inference providers:
 | OpenAI | API Key | No | [Link](#openai) |
 | Google Gemini | API Key | Yes | [Link](#google-gemini) |
 | Mistral AI | API Key | Limited | [Link](#mistral-ai) |
+| Fireworks AI | API Key | No | [Link](#fireworks-ai) |
 | Ollama | None | Yes | [Link](#ollama-local) |
 | Azure OpenAI | API Key | No | [Link](#azure-openai) |
 
@@ -103,11 +104,51 @@ export MISTRAL_API_KEY=...
 tau --model mistral/mistral-large -p "Say hello"
 ```
 
+## Fireworks AI
+
+Fireworks AI provides fast, cost-efficient inference for open-source models including Llama, DeepSeek, Qwen, and Mixtral — with OpenAI-compatible APIs.
+
+**Text models**:
+
+| Model | Context | Pricing (in/out per M tokens) |
+|-------|---------|-------------------------------|
+| `accounts/fireworks/models/llama-v3p3-70b-instruct` | 131K | $0.90 / $0.90 |
+| `accounts/fireworks/models/llama-v3p1-405b-instruct` | 131K | $3.00 / $3.00 |
+| `accounts/fireworks/models/deepseek-r1` *(thinking)* | 160K | $3.00 / $7.00 |
+| `accounts/fireworks/models/deepseek-v3` | 131K | $0.90 / $0.90 |
+| `accounts/fireworks/models/qwen3-235b-a22b` *(thinking)* | 131K | $0.22 / $0.88 |
+| `accounts/fireworks/models/qwen3-30b-a3b` *(thinking)* | 131K | $0.15 / $0.60 |
+| `accounts/fireworks/models/mixtral-8x22b-instruct` | 65K | $0.90 / $0.90 |
+| `accounts/fireworks/models/gemma2-9b-it` | 8K | $0.20 / $0.20 |
+
+**Image models**: Flux 1 Schnell FP8, Flux 1 Dev FP8
+
+### Setup
+
+1. Create an account at [Fireworks AI](https://fireworks.ai)
+2. Generate an API key in your account settings
+3. Set the environment variable:
+
+```bash
+export FIREWORKS_API_KEY=fw_...
+```
+
+### Verify
+
+```bash
+tau --model fireworks/accounts/fireworks/models/llama-v3p3-70b-instruct -p "Say hello"
+```
+
+### Notes
+
+- Uses the OpenAI-compatible completions API under the hood
+- Session affinity is maintained automatically via a per-request `x-session-affinity` header
+
 ## Ollama (Local)
 
 Run open-source models locally without API keys or internet.
 
-**Models**: `llama2`, `mistral`, `neural-chat`, and [others](https://ollama.ai/library)
+**Models**: `llama2`, `mistral`, `neural-chat`, `qwen3.5:cloud` (262K context, thinking), and [others](https://ollama.ai/library)
 
 ### Setup
 

{tau_coding_agent-0.3.5 → tau_coding_agent-0.3.9}/docs/settings.md

@@ -187,6 +187,10 @@ When your conversation grows long, tau automatically summarizes older messages t
 - **`reserve_tokens`**: How many tokens to keep available for the LLM's response (default 16,384 ≈ 4K-5K words)
 - **`keep_recent_tokens`**: How many recent message tokens to preserve word-for-word before summarization kicks in (default 20,000 ≈ 5K-6K words)
 
+#### Mid-turn (threshold) compaction
+
+In addition to compaction triggered at the start of a turn, tau can compact **mid-turn** when the context hits the configured limit while the agent is already running. When this happens the engine stops cleanly so you can review the compacted context and continue — no partial output is lost. Tool output lines are truncated before sending to the LLM to help prevent hitting the threshold in the first place.
+
 Example configurations:
 
 ```json
@@ -284,6 +288,10 @@ These settings are applied to the LLM client at startup:
 
 Changes take effect on the next session start or after `/reload`.
 
+#### Adaptive retry delay
+
+When a provider responds with a `Retry-After` or `Retry-After-Ms` header (common on rate-limit responses), tau uses that value as the retry delay instead of the configured `base_delay_ms`. The delay is capped at **60 seconds** so a provider that returns an extreme value (e.g. "retry in 16 days") doesn't stall the agent indefinitely. When no header is present, `base_delay_ms` is used.
+
 ```json
 {
   "retry": {
@@ -442,11 +450,11 @@ All retry settings are **fully implemented and wired to the LLM client at startu
 All thinking budget settings are **fully implemented and configurable**:
 
 - **`thinking_budgets.minimal`**: Token budget for "minimal" level (default: `1024`)
-- **`thinking_budgets.low`**: Token budget for "low" level (default: `2048`)
-- **`thinking_budgets.medium`**: Token budget for "medium" level (default: `4096`)
-- **`thinking_budgets.high`**: Token budget for "high" level (default: `8192`)
-- **`thinking_budgets.xhigh`**: Token budget for "xhigh" level (default: `16384`)
-- **`thinking_budgets.max`**: Token budget for "max" level (default: `32768`)
+- **`thinking_budgets.low`**: Token budget for "low" level (default: `4096`)
+- **`thinking_budgets.medium`**: Token budget for "medium" level (default: `8192`)
+- **`thinking_budgets.high`**: Token budget for "high" level (default: `16384`)
+- **`thinking_budgets.xhigh`**: Token budget for "xhigh" level (default: `32768`)
+- **`thinking_budgets.max`**: Token budget for "max" level (default: `65536`)
 
 Override these to customize extended thinking token allocations for your workflow.
 

{tau_coding_agent-0.3.5 → tau_coding_agent-0.3.9}/docs/usage.md

@@ -102,8 +102,8 @@ Prints session info inline in the chat. Shows:
 
 - **Session Info** — Name (if set), File path, ID
 - **Messages** — User, Assistant, Tool calls, Tool results, Total
-- **Tokens** — Input, Output, Cache read (if any), Cache write (if any), Total
-- **Cost** — Total USD cost (only shown if non-zero)
+- **Tokens** — Input, Output, Cache read (if any), Cache write (if any), Total — counts use human-readable suffixes (e.g. `1.2K`, `3.4M`); each line shows an inline cost estimate in USD
+- **Cost** — Total USD cost with inline estimate (only shown if non-zero)
 
 ### `/copy`
 

{tau_coding_agent-0.3.5 → tau_coding_agent-0.3.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.3.5"
+version = "0.3.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"
@@ -68,6 +68,9 @@ tau = [
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 
+[project.optional-dependencies]
+tools = ["ripgrep>=14.0.0"]
+
 [dependency-groups]
 dev = [
     "pytest>=9.1.1",

{tau_coding_agent-0.3.5 → tau_coding_agent-0.3.9}/tau/agent/prompt/builder.py

@@ -93,7 +93,8 @@ def load_project_context_files(cwd: Path) -> list[tuple[str, Path]]:
 
 
 _DEFAULT_IDENTITY = """\
-You are a coding agent operating inside Tau, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
+You are a coding agent operating inside Tau, a coding agent harness. You help users by
+reading files, executing commands, editing code, and writing new files.
 
 You have strong software engineering skills. You think carefully before making changes,
 and follow the existing style and conventions of the project.
@@ -101,10 +102,13 @@ and follow the existing style and conventions of the project.
 
 _GENERAL_GUIDELINES = [
     "If a task is ambiguous, ask a precise, clarifying question before proceeding.",
-    "Do only what the task asks; don't add features, refactors, or abstractions beyond scope.",
+    ("Do only what the task asks; don't add features, refactors, or abstractions beyond scope."),
     "Write comments when the *why* is non-obvious — well-named code explains itself.",
     "Keep responses short, concise, and direct; don't summarize what you just did.",
-    "Prioritize accuracy over agreement — investigate before confirming, and disagree when the evidence calls for it.",
+    (
+        "Prioritize accuracy over agreement — investigate before confirming, and "
+        "disagree when the evidence calls for it."
+    ),
 ]
 
 
@@ -231,7 +235,9 @@ class PromptBuilder:
         append = self._append()
         git = self._git_section()
         footer = self._footer()
-        return identity + guidelines + tools + docs + project_context + skills + append + git + footer
+        return (
+            identity + guidelines + tools + docs + project_context + skills + append + git + footer
+        )
 
     # ------------------------------------------------------------------
     # Layers
@@ -267,7 +273,10 @@ class PromptBuilder:
             if guideline:
                 guidelines.append(f"- **{t.name}**: {guideline.strip()}")
         section = "\n\n# Available Tools\n\n" + "\n".join(lines)
-        section+="\nIn addition to the tools above, you may have access to other custom tools depending on the project."
+        section += (
+            "\nIn addition to the tools above, you may have access to other custom "
+            "tools depending on the project."
+        )
         if guidelines:
             section += "\n\n## Tool Guidelines\n\n" + "\n".join(guidelines)
         return section
@@ -297,9 +306,7 @@ class PromptBuilder:
         return (
             "\n\n# Project Instructions\n\n"
             "Project-specific guidelines (follow before general Tau guidelines):\n\n"
-            "<project_context>\n\n"
-            + blocks
-            + "</project_context>"
+            "<project_context>\n\n" + blocks + "</project_context>"
         )
 
     def _docs_section(self) -> str:

{tau_coding_agent-0.3.5 → tau_coding_agent-0.3.9}/tau/agent/service.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -8,17 +9,33 @@ from tau.agent.types import AgentConfig, AgentContext, AgentPhase, ContextUsage,
 from tau.hooks.engine import MessageEndEvent, MessageRollbackEvent, SavePointEvent, SettledEvent
 from tau.hooks.service import Hooks
 from tau.message.types import (
-    AgentMessage,
     AssistantMessage,
     LLMMessage,
-    TerminalExecutionMessage,
-    TextContent,
     ToolMessage,
     UserMessage,
 )
 from tau.message.utils import strip_unusable_trailing_assistant
+from tau.session.utils import to_llm_messages as _to_llm_messages
 from tau.tool.types import ToolInvocation, ToolResult
 
+_log = logging.getLogger(__name__)
+
+_TOOL_CAP_BYTES = 50 * 1024   # 50 KB — DEFAULT_MAX_BYTES
+_TOOL_CAP_LINES = 2000         # DEFAULT_MAX_LINES
+_TOOL_LINE_CAP_BYTES = 2 * 1024  # 2 KB — max bytes for a single line
+
+
+from tau.hooks.engine import CompactionReason as _CompactionReason
+from tau.session.compaction import ThresholdCompactionStop as _ThresholdCompactionStop
+
+
+def _fmt_size(n: int) -> str:
+    if n < 1024:
+        return f"{n}B"
+    if n < 1024 * 1024:
+        return f"{n / 1024:.1f}KB"
+    return f"{n / (1024 * 1024):.1f}MB"
+
 if TYPE_CHECKING:
     from tau.engine.service import Engine
     from tau.runtime.service import Runtime
@@ -26,37 +43,6 @@ if TYPE_CHECKING:
     from tau.session.manager import SessionManager
 
 
-def _to_llm_messages(messages: list[AgentMessage]) -> list[LLMMessage]:
-    """Convert AgentMessages to LLM-compatible messages.
-
-    TerminalExecutionMessage   → UserMessage (Ran `cmd`\n```output```)
-    CompactionSummaryMessage → UserMessage with summary wrapped in XML tags
-    CustomMessage and other non-LLM types → skipped
-    Empty AssistantMessages are visual-only markers (aborts, persisted API/credit
-    errors) and are skipped — an assistant turn with neither content nor tool
-    calls is invalid to send back and triggers provider 400s.
-    """
-    from tau.message.types import CompactionSummaryMessage, ThinkingContent, ToolCallContent
-
-    result: list[LLMMessage] = []
-    for msg in messages:
-        if isinstance(msg, CompactionSummaryMessage):
-            text = f"<context-summary>\n{msg.summary}\n</context-summary>"
-            result.append(UserMessage.from_text(text))
-        elif isinstance(msg, TerminalExecutionMessage):
-            if not msg.exclude:
-                result.append(msg.to_user_message())
-        elif isinstance(msg, AssistantMessage):
-            has_usable = any(
-                isinstance(c, (TextContent, ToolCallContent, ThinkingContent)) for c in msg.contents
-            )
-            if has_usable:
-                result.append(msg)
-        elif isinstance(msg, (UserMessage, ToolMessage)):
-            result.append(msg)
-    return result
-
-
 class Agent:
     """
     High-level agent session tying together Engine and SessionManager.
@@ -87,6 +73,7 @@ class Agent:
         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
+        self._engine.options.transform_context = self._transform_context
 
     # -------------------------------------------------------------------------
     # Public interface
@@ -179,6 +166,79 @@ class Agent:
         result: ToolResult,
         signal: asyncio.Event | None,
     ) -> ToolResult | None:
+        """Cap oversized tool output before it enters the context window.
+
+        Hard cap on tool output size 50 KB / 2000-line 
+        Head-truncation keeps the first N lines/bytes; a trailing marker
+        reports how much was omitted and the total size.
+        """
+        content = result.content
+        raw = content.encode("utf-8", errors="replace")
+        total_bytes = len(raw)
+        lines = content.split("\n")
+        total_lines = len(lines)
+
+        if total_bytes <= _TOOL_CAP_BYTES and total_lines <= _TOOL_CAP_LINES:
+            return result
+
+        # Cap individual lines that would consume the entire budget on their own
+        # (e.g. minified JS). Truncate each line to _TOOL_LINE_CAP_BYTES.
+        capped_lines: list[str] = []
+        for line in lines:
+            lb = len(line.encode("utf-8", errors="replace"))
+            if lb > _TOOL_LINE_CAP_BYTES:
+                buf = line.encode("utf-8", errors="replace")[:_TOOL_LINE_CAP_BYTES]
+                # Walk back to a valid UTF-8 boundary
+                while buf and (buf[-1] & 0xC0) == 0x80:
+                    buf = buf[:-1]
+                capped_lines.append(buf.decode("utf-8", errors="replace") + f" …[line truncated: {_fmt_size(lb)} → {_fmt_size(_TOOL_LINE_CAP_BYTES)}]")
+            else:
+                capped_lines.append(line)
+        lines = capped_lines
+
+        kept: list[str] = []
+        byte_count = 0
+        for i, line in enumerate(lines):
+            if i >= _TOOL_CAP_LINES:
+                break
+            enc = len(line.encode("utf-8", errors="replace")) + (1 if i > 0 else 0)
+            if byte_count + enc > _TOOL_CAP_BYTES:
+                break
+            kept.append(line)
+            byte_count += enc
+
+        omitted = total_bytes - byte_count
+        kept.append(
+            f"[truncated: {_fmt_size(omitted)} omitted"
+            f" — {_fmt_size(total_bytes)} total, showing first {len(kept)} lines / {_fmt_size(byte_count)}]"
+        )
+        return ToolResult(
+            id=result.id,
+            content="\n".join(kept),
+            is_error=result.is_error,
+            metadata=result.metadata,
+            terminate=result.terminate,
+            terminate_message=result.terminate_message,
+        )
+
+    async def _transform_context(
+        self,
+        messages: list[LLMMessage],
+        signal: asyncio.Event | None,
+    ) -> list[LLMMessage]:
+        """Called before every LLM inference in the engine loop.
+
+        Runs a compaction check so it can fire between tool iterations
+        (not only at invoke() boundaries), then rebuilds the message list
+        from the current session so the engine always sees up-to-date
+        compacted history.
+        """
+        threshold_stop = await self._check_compaction()
+        session_ctx = self._session_manager.build_session_context()
+        llm_messages = _to_llm_messages(session_ctx.messages)
+        result = strip_unusable_trailing_assistant(llm_messages, self._session_manager)
+        if threshold_stop:
+            raise _ThresholdCompactionStop()
         return result
 
     # -------------------------------------------------------------------------
@@ -225,7 +285,8 @@ class Agent:
         if preparation is None:
             return False
         await self._apply_compaction(
-            preparation, entries, manual=True, custom_instructions=custom_instructions
+            preparation, entries, manual=True, custom_instructions=custom_instructions,
+            reason=_CompactionReason.Manual,
         )
         return True
 
@@ -235,12 +296,15 @@ class Agent:
         entries: list,
         manual: bool,
         custom_instructions: str | None = None,
+        reason: _CompactionReason = _CompactionReason.Manual,
     ) -> None:
         """Run a prepared compaction, persist the summary, and emit the end event."""
         from tau.hooks.engine import CompactionEndEvent
 
+        will_retry = reason == _CompactionReason.Overflow
         result, from_extension = await self._run_compaction(
-            preparation, entries, manual=manual, custom_instructions=custom_instructions
+            preparation, entries, manual=manual, custom_instructions=custom_instructions,
+            reason=reason, will_retry=will_retry,
         )
         self._session_manager.append_compaction(
             summary=result.summary,
@@ -254,32 +318,40 @@ class Agent:
                 tokens_before=result.tokens_before,
                 summary_length=len(result.summary),
                 from_extension=from_extension,
+                reason=reason,
+                will_retry=will_retry,
             )
         )
 
-    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
+    def _latest_model_change_timestamp(self) -> float | None:
+        """Timestamp of the most recent model-change entry in the active branch, if any."""
+        from tau.session.types import ModelChangeEntry
 
         for entry in reversed(self._session_manager.get_branch()):
-            if isinstance(entry, CompactionEntry):
+            if isinstance(entry, ModelChangeEntry):
                 return entry.timestamp
         return None
 
-    async def _check_compaction(self) -> None:
-        """Auto-compact if context usage exceeds the threshold. Circuit-breaks after 3 failures."""
+    async def _check_compaction(self) -> bool:
+        """Auto-compact if context usage exceeds the threshold. Circuit-breaks after 3 failures.
+
+        Returns True if threshold compaction ran (caller should stop the current turn),
+        False otherwise (overflow-forced compaction or no compaction needed).
+        """
         from tau.session.compaction import (
             estimate_context_tokens,
+            is_silent_overflow,
+            latest_compaction_timestamp,
             prepare_compaction,
             should_compact,
         )
 
         if self._compaction_failures >= 3:
-            return
+            return False
 
         settings = self._config.compaction
         if not settings.enabled:
-            return
+            return False
 
         entries = self._session_manager.get_branch()
         session_ctx = self._session_manager.build_session_context()
@@ -292,48 +364,46 @@ class Agent:
         # (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)
+
+        # Model-switch guard: if the last assistant message is older than the most recent
+        # model change, it came from a different model. Treating its usage/overflow data as
+        # a signal for the new model is unreliable (context windows differ), so skip.
+        model_change_ts = self._latest_model_change_timestamp()
+        if model_change_ts is not None and last is not None:
+            if last.timestamp <= model_change_ts:
+                return False
+
+        forced = last is not None and is_silent_overflow(last, self._context_window)
 
         if not forced:
             if not should_compact(usage.tokens, self._context_window, settings):
-                return
+                return False
             # 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()
+                comp_ts = latest_compaction_timestamp(entries)
                 if comp_ts is not None and getattr(anchor, "timestamp", 0.0) <= comp_ts:
-                    return
+                    return False
 
         preparation = prepare_compaction(entries, settings)
         if preparation is None:
-            return
+            return False
 
         try:
-            await self._apply_compaction(preparation, entries, manual=False)
+            await self._apply_compaction(
+                preparation, entries, manual=False,
+                reason=_CompactionReason.Overflow if forced else _CompactionReason.Threshold,
+            )
+            # Threshold compaction: caller should stop the turn; user resumes manually.
+            # Forced (silent overflow) compaction: caller should continue — the LLM
+            # never got a usable response, so there's nothing for the user to resume from.
+            return not forced
         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:
+            _log.exception("Auto-compaction failed")
             return False
-        u = message.usage
-        inp = u.input_tokens + u.cache_read_tokens
-        if message.stop_reason == StopReason.Stop and inp > cw:
-            return True
-        return bool(
-            message.stop_reason == StopReason.Length and u.output_tokens == 0 and inp >= cw * 0.99
-        )
 
     async def _try_overflow_recovery(self) -> bool:
         """If the last turn died with a context-overflow error, compact once and signal a retry.
@@ -349,6 +419,13 @@ class Agent:
         if last is None or last.error_kind != ErrorKind.CONTEXT_OVERFLOW:
             return False
 
+        # Model-switch guard: the overflow error is from a different model if it predates
+        # the most recent model-change entry. Skip recovery — the new model may handle the
+        # context fine, and compacting based on a stale signal wastes history.
+        model_change_ts = self._latest_model_change_timestamp()
+        if model_change_ts is not None and last.timestamp <= model_change_ts:
+            return False
+
         if self._overflow_recovery_attempted:
             self._notify(
                 "Context overflow recovery failed after compaction. "
@@ -366,9 +443,10 @@ class Agent:
         if preparation is None:
             return False
         try:
-            await self._apply_compaction(preparation, entries, manual=False)
+            await self._apply_compaction(preparation, entries, manual=False, reason=_CompactionReason.Overflow)
         except Exception:
             self._compaction_failures += 1
+            _log.exception("Overflow-triggered compaction failed")
             return False
         return True
 
@@ -388,6 +466,8 @@ class Agent:
         entries: list,
         manual: bool,
         custom_instructions: str | None = None,
+        reason: _CompactionReason = _CompactionReason.Manual,
+        will_retry: bool = False,
     ) -> tuple:
         """Emit before_compaction (allowing interception), then run the default algorithm.
 
@@ -408,6 +488,8 @@ class Agent:
                 preparation=preparation,
                 entries=entries,
                 manual=manual,
+                reason=reason,
+                will_retry=will_retry,
             )
         )
 
@@ -419,7 +501,7 @@ class Agent:
             if res.compaction is not None:
                 return res.compaction, True
 
-        await self.hooks.emit(CompactionStartEvent(manual=manual))
+        await self.hooks.emit(CompactionStartEvent(manual=manual, reason=reason, will_retry=will_retry))
         result = await _compact(
             preparation, self._engine.llm, custom_instructions=custom_instructions
         )  # type: ignore[arg-type]
@@ -438,10 +520,6 @@ class Agent:
 
         opts = options or PromptOptions()
 
-        # 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()
-
         user_message = UserMessage.with_media(
             text,
             list(opts.images) if opts.images else None,

{tau_coding_agent-0.3.5 → tau_coding_agent-0.3.9}/tau/auth/manager.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import builtins
 import json
+import logging
 import os
 from pathlib import Path
 
@@ -19,6 +20,8 @@ from tau.inference.provider.registry import ProviderRegistry
 from tau.settings.paths import get_auth_path
 from tau.utils.secrets import resolve_secret
 
+_log = logging.getLogger(__name__)
+
 
 def _get_env_api_key(provider: str) -> str | None:
     """Get API key for a provider from environment variables."""
@@ -79,12 +82,12 @@ class AuthManager:
         return AuthManager(registry, storage)
 
     @staticmethod
-    def in_memory(registry: ProviderRegistry, initial: dict = None) -> AuthManager:
+    def in_memory(registry: ProviderRegistry, initial: dict | None = None) -> AuthManager:
         """Create AuthManager with in-memory storage for testing."""
         if initial is None:
             initial = {}
         storage = InMemoryAuthStorage()
-        storage.with_lock(lambda _: LockResult(result=None, next=json.dumps(initial, indent=2)))
+        storage.with_lock(lambda _: LockResult(result=initial, next=json.dumps(initial, indent=2)))  # type: ignore[arg-type]
         return AuthManager.from_storage(registry, storage)
 
     def _record_error(self, error: Exception) -> None:
@@ -274,6 +277,7 @@ class AuthManager:
                     result=refreshed_credential, next=json.dumps(serialized, indent=2)
                 )
             except Exception as e:
+                _log.error("oauth token refresh failed for %s: %s", provider, e, exc_info=True)
                 self._record_error(e)
                 return LockResult(result=None)