tau-coding-agent 0.1.0__py3-none-any.whl

tau/runtime/types.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, Field
+
+from tau.agent.service import Agent
+from tau.agent.types import AgentConfig
+from tau.builtins.tools import TOOLS
+from tau.engine.service import Engine, EngineOptions
+from tau.extensions.api import _RuntimeRef, LoadExtensionsResult
+from tau.extensions.events import EventBus
+from tau.extensions.loader import ExtensionLoader
+from tau.extensions.runtime import ExtensionRuntime
+from tau.hooks.service import Hooks
+from tau.inference.api.text.service import TextLLM as LLM
+from tau.agent.prompt.builder import build_prompt
+from tau.agent.prompt.types import PromptOptions
+from tau.session.manager import SessionManager
+from tau.settings.manager import SettingsManager
+from tau.settings.paths import get_config_dir, get_extensions_dir
+from tau.tool.types import Tool
+from tau.tool.registry import ToolRegistry
+
+
+def _is_project_package(settings_manager: SettingsManager, name: str) -> bool:
+    """Return True if the package is project-scoped (in project settings)."""
+    project_pkgs = settings_manager.get_packages(local=True)
+    return any(p.name == name for p in project_pkgs)
+
+
+class RuntimeConfig(BaseModel):
+    """Immutable configuration snapshot passed to RuntimeContext.create()."""
+    model_config = {'arbitrary_types_allowed': True}
+
+    cwd: Path
+    config_dir: Path | None = None
+
+    # LLM
+    model_id: str | None = None
+    provider: str | None = None
+
+    # Session
+    session_file: Path | None = None
+    persist_session: bool = True
+    resume: bool = False
+
+    # Run mode
+    mode: str = "interactive"
+
+    # Tools & prompt
+    tools: list[Tool] = Field(default_factory=list)
+    system_prompt: str = ""
+    disable_context_files: bool = False
+
+    # Trust
+    project_trusted: bool | None = None  # None = auto-detect from trust store
+
+
+class RuntimeContext:
+    """
+    Constructs and owns all dependencies for one Agent session.
+
+    Usage:
+        ctx = await RuntimeContext.create(config)
+        agent = ctx.agent
+        await agent.invoke("hello")
+    """
+
+    def __init__(
+        self,
+        agent: Agent,
+        llm: LLM,
+        engine: Engine,
+        session_manager: SessionManager,
+        settings_manager: SettingsManager | None = None,
+        hooks: Hooks | None = None,
+        ext_runtime: ExtensionRuntime | None = None,
+        tool_registry: ToolRegistry | None = None,
+    ) -> None:
+        self.agent = agent
+        self.llm = llm
+        self.engine = engine
+        self.session_manager = session_manager
+        self.settings_manager = settings_manager
+        self.hooks: Hooks = hooks or agent.hooks
+        self.ext_runtime: ExtensionRuntime | None = ext_runtime
+        self.tool_registry: ToolRegistry = tool_registry or ToolRegistry()
+
+    @classmethod
+    async def create(
+        cls,
+        config: RuntimeConfig,
+        settings_manager: SettingsManager | None = None,
+        hooks: Hooks | None = None,
+        ext_runtime: ExtensionRuntime | None = None,
+    ) -> RuntimeContext:
+        """Bootstrap every dependency from config and return a fully wired context."""
+        cwd = config.cwd.resolve()
+        config_dir = (config.config_dir or get_config_dir()).resolve()
+
+        # Determine project trust status (needed for context file loading)
+        project_trusted: bool
+        if config.project_trusted is not None:
+            project_trusted = config.project_trusted
+        else:
+            # Will be determined below based on trust settings
+            project_trusted = False
+
+        # ── Settings ──────────────────────────────────────────────────────────
+        if settings_manager is None:
+            from tau.trust.manager import has_project_trust_inputs, trust_store
+            if not has_project_trust_inputs(cwd):
+                project_trusted = True
+            elif config.project_trusted is not None:
+                project_trusted = config.project_trusted
+            else:
+                # Load global settings first to read project_trust policy
+                _global_sm = SettingsManager.create(cwd, config_dir=config_dir, project_trusted=False)
+                policy = _global_sm.get_project_trust()
+                if policy == "always":
+                    project_trusted = True
+                elif policy == "never":
+                    project_trusted = False
+                else:
+                    stored = trust_store.get(cwd)
+                    project_trusted = stored if stored is not None else False
+            settings_manager = SettingsManager.create(cwd, config_dir=config_dir, project_trusted=project_trusted)
+
+        # ── LLM ───────────────────────────────────────────────────────────────
+        _DEFAULT_MODEL = "claude-sonnet-4-6"
+        model_id = config.model_id or settings_manager.get_model() or _DEFAULT_MODEL
+        if config.model_id is not None:
+            provider = config.provider
+        else:
+            provider = config.provider or settings_manager.get_provider()
+        llm = LLM(model_id=model_id, provider=provider)
+        from datetime import timedelta
+        llm.api.options.timeout = timedelta(milliseconds=settings_manager.get_http_idle_timeout_ms())
+        if settings_manager.is_retry_enabled():
+            llm.api.options.max_retries = settings_manager.get_retry_max_retries()
+            llm.api.options.retry_base_delay_ms = settings_manager.get_retry_base_delay_ms()
+        else:
+            llm.api.options.max_retries = 0
+        if llm.model.thinking:
+            llm.api.options.thinking_level = settings_manager.get_thinking_level() or llm.model.default_thinking_level
+
+        # ── Session manager ───────────────────────────────────────────────────
+        if config.resume and not config.session_file and config.persist_session:
+            session_manager = SessionManager.continue_recent(cwd)
+        else:
+            session_manager = SessionManager(
+                cwd=cwd,
+                session_file=config.session_file,
+                persist=config.persist_session,
+            )
+
+        # ── Shared hook bus ───────────────────────────────────────────────────
+        hooks = hooks or Hooks()
+
+        # ── Extensions ────────────────────────────────────────────────────────
+        # Only load on first session; on session switch the caller passes ext_runtime.
+        base_tools: list[Tool] = list(TOOLS) + list(config.tools)
+
+        if ext_runtime is None:
+            from tau.settings.paths import get_builtins_dir
+            from tau.hooks.runtime import RuntimeStartEvent
+            builtins_ext_dir = get_builtins_dir() / "extensions"
+            runtime_ref = _RuntimeRef()
+
+            # Earliest lifecycle signal — hooks bus exists, nothing loaded yet.
+            # Reaches core/manual subscribers only (no extensions registered yet);
+            # opens the runtime_start → runtime_ready → runtime_stop bracket.
+            await hooks.emit(RuntimeStartEvent())
+
+            if settings_manager.is_extensions_enabled():
+                project_ext_dir = get_extensions_dir(cwd)
+                global_ext_dir = get_extensions_dir()
+                entries = settings_manager.get_extension_list()
+                disabled_stems = {Path(e.path).stem for e in entries if not e.enabled}
+                entry_configs = {
+                    Path(e.path).stem: (e.settings or {})
+                    for e in entries if e.enabled
+                }
+                extra_entries = [e for e in entries if e.enabled]
+                extra_sources: dict[str, str] = {}
+
+                # Discover extension files contributed by installed packages
+                from tau.packages.manager import PackageManager
+                from tau.settings.paths import get_packages_venv
+                from tau.settings.types import ExtensionEntry as _ExtEntry
+                pkg_entries = settings_manager.get_all_packages()
+                if pkg_entries:
+                    for _scope_local in (False, True):
+                        _venv_dir = get_packages_venv(cwd if _scope_local else None)
+                        _pkg_mgr = PackageManager(_venv_dir)
+                        _site = _pkg_mgr.site_packages()
+                        if _site and str(_site) not in sys.path:
+                            sys.path.insert(0, str(_site))
+                    for pkg in pkg_entries:
+                        if not pkg.enabled:
+                            continue
+                        _venv_dir = get_packages_venv(
+                            cwd if _is_project_package(settings_manager, pkg.name) else None
+                        )
+                        _pkg_mgr = PackageManager(_venv_dir)
+                        for ext_file in _pkg_mgr.find_extension_files(pkg.name, pkg.installed_path):
+                            extra_entries.append(_ExtEntry(path=str(ext_file), name=pkg.name))
+                            extra_sources[str(ext_file)] = "package"
+                loader = ExtensionLoader(
+                    builtins_dir=builtins_ext_dir,
+                    project_dir=project_ext_dir,
+                    global_dir=global_ext_dir,
+                    extra_entries=extra_entries,
+                    extra_sources=extra_sources,
+                    disabled_stems=disabled_stems,
+                    entry_configs=entry_configs,
+                    llm=llm,
+                    settings=settings_manager,
+                    cwd=cwd,
+                    runtime_ref=runtime_ref,
+                    events=EventBus(),
+                )
+            else:
+                # Extensions disabled — load builtins only.
+                loader = ExtensionLoader(
+                    builtins_dir=builtins_ext_dir,
+                    llm=llm,
+                    settings=settings_manager,
+                    cwd=cwd,
+                    runtime_ref=runtime_ref,
+                    events=EventBus(),
+                )
+            load_result = await loader.load()
+            ext_runtime = ExtensionRuntime(load_result, hooks, runtime_ref)
+
+        assert ext_runtime is not None
+        # Collect tools and prompt appends contributed by extensions
+        extra_appends = ext_runtime.get_prompt_appends()
+
+        # ── Tool registry ─────────────────────────────────────────────────────
+        tool_registry = ToolRegistry()
+        for tool in base_tools:
+            source = "builtin" if tool in list(TOOLS) else "runtime"
+            tool_registry.register(tool, source=source)
+        for tool in ext_runtime.get_tools():
+            tool_registry.register(tool, source="extension")
+
+        all_tools: list[Tool] = tool_registry.list()
+
+        # ── Engine ────────────────────────────────────────────────────────────
+        engine = Engine(
+            cwd=cwd,
+            llm=llm,
+            tools=all_tools,
+            options=EngineOptions(),
+            hooks=hooks,
+            settings=settings_manager,
+        )
+
+        # ── Skills ────────────────────────────────────────────────────────────
+        from tau.skills.registry import skill_registry
+        skill_registry.load_external(cwd=cwd)
+        skills = skill_registry.list()
+
+        # ── System prompt ─────────────────────────────────────────────────────
+        system_prompt = config.system_prompt or build_prompt(PromptOptions(
+            cwd=cwd,
+            tools=all_tools,
+            extra_appends=extra_appends,
+            skills=skills,
+            disable_context_files=config.disable_context_files,
+            project_trusted=project_trusted,
+        ))
+
+        # ── Agent config ──────────────────────────────────────────────────────
+        agent_config = AgentConfig(
+            cwd=cwd,
+            system_prompt=system_prompt,
+            model=llm.model,
+            context_window=llm.model.context_window or 200_000,
+        )
+
+        # ── Agent ─────────────────────────────────────────────────────────────
+        agent = Agent(
+            engine=engine,
+            session_manager=session_manager,
+            config=agent_config,
+            hooks=hooks,
+        )
+
+        return cls(
+            agent=agent,
+            llm=llm,
+            engine=engine,
+            session_manager=session_manager,
+            settings_manager=settings_manager,
+            hooks=hooks,
+            ext_runtime=ext_runtime,
+            tool_registry=tool_registry,
+        )

tau/session/branch_summarization.py

@@ -0,0 +1,312 @@
+"""
+Branch summarization for tree navigation.
+
+When navigating to a different point in the session tree, this generates
+a summary of the branch being left so context isn't lost.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from tau.inference.api.text.service import TextLLM
+    from tau.session.manager import SessionManager
+    from tau.session.types import SessionEntry
+
+
+# ---------------------------------------------------------------------------
+# Types
+# ---------------------------------------------------------------------------
+
+@dataclass
+class BranchSummaryResult:
+    summary: str | None = None
+    read_files: list[str] = field(default_factory=list)
+    modified_files: list[str] = field(default_factory=list)
+    aborted: bool = False
+    error: str | None = None
+
+
+@dataclass
+class BranchSummaryDetails:
+    """Stored in BranchSummaryEntry.details for cumulative file tracking."""
+    read_files: list[str] = field(default_factory=list)
+    modified_files: list[str] = field(default_factory=list)
+
+
+@dataclass
+class FileOperations:
+    read: set[str] = field(default_factory=set)
+    written: set[str] = field(default_factory=set)
+    edited: set[str] = field(default_factory=set)
+
+
+@dataclass
+class BranchPreparation:
+    messages: list
+    file_ops: FileOperations
+    total_tokens: int
+
+
+@dataclass
+class CollectEntriesResult:
+    entries: list[SessionEntry]
+    common_ancestor_id: str | None
+
+
+# ---------------------------------------------------------------------------
+# Entry collection
+# ---------------------------------------------------------------------------
+
+def collect_entries_for_branch_summary(
+    session: SessionManager,
+    old_leaf_id: str | None,
+    target_id: str,
+) -> CollectEntriesResult:
+    """Collect entries that should be summarized when navigating from old_leaf_id to target_id."""
+    if not old_leaf_id:
+        return CollectEntriesResult(entries=[], common_ancestor_id=None)
+
+    old_path = {e.id for e in session.get_branch(old_leaf_id)}
+    target_path = session.get_branch(target_id)
+
+    common_ancestor_id: str | None = None
+    for entry in reversed(target_path):
+        if entry.id in old_path:
+            common_ancestor_id = entry.id
+            break
+
+    entries: list[SessionEntry] = []
+    current: str | None = old_leaf_id
+    while current and current != common_ancestor_id:
+        entry = session.get_entry(current)
+        if not entry:
+            break
+        entries.append(entry)
+        current = entry.parent_id
+
+    entries.reverse()
+    return CollectEntriesResult(entries=entries, common_ancestor_id=common_ancestor_id)
+
+
+# ---------------------------------------------------------------------------
+# Entry → message conversion
+# ---------------------------------------------------------------------------
+
+def _get_message_from_entry(entry: Any) -> Any | None:
+    from tau.session.types import (
+        MessageEntry, CustomMessageEntry, BranchSummaryEntry, CompactionEntry,
+        ThinkingLevelChangeEntry, ModelChangeEntry, CustomInfoEntry,
+        LabelEntry, LeafEntry, SessionInfoEntry,
+    )
+    from tau.message.types import CustomMessage, BranchSummaryMessage, CompactionSummaryMessage
+
+    if isinstance(entry, MessageEntry):
+        from tau.message.types import ToolMessage
+        if isinstance(entry.message, ToolMessage):
+            return None
+        return entry.message
+    if isinstance(entry, CustomMessageEntry):
+        return CustomMessage.from_session(entry=entry)
+    if isinstance(entry, BranchSummaryEntry):
+        return BranchSummaryMessage(
+            summary=entry.summary,
+            from_id=entry.from_id,
+            timestamp=entry.timestamp,
+        )
+    if isinstance(entry, CompactionEntry):
+        return CompactionSummaryMessage(
+            summary=entry.summary,
+            tokens_before=entry.tokens_before,
+            timestamp=entry.timestamp,
+        )
+    return None
+
+
+def _extract_file_ops_from_message(message: Any, file_ops: FileOperations) -> None:
+    from tau.message.types import AssistantMessage, ToolCallContent
+
+    if not isinstance(message, AssistantMessage):
+        return
+    for c in message.contents:
+        if not isinstance(c, ToolCallContent):
+            continue
+        path = c.args.get("path") if isinstance(c.args, dict) else None
+        if not isinstance(path, str):
+            continue
+        if c.name == "read":
+            file_ops.read.add(path)
+        elif c.name == "write":
+            file_ops.written.add(path)
+        elif c.name == "edit":
+            file_ops.edited.add(path)
+
+
+# ---------------------------------------------------------------------------
+# Preparation
+# ---------------------------------------------------------------------------
+
+def prepare_branch_entries(entries: list[Any], token_budget: int = 0) -> BranchPreparation:
+    """
+    Walk entries from newest to oldest, adding messages until the token budget is hit.
+    File ops are collected from ALL entries regardless of token budget.
+    """
+    from tau.session.compaction import estimate_tokens
+    from tau.session.types import BranchSummaryEntry
+
+    messages: list = []
+    file_ops = FileOperations()
+    total_tokens = 0
+
+    # First pass: collect file ops from existing branch summaries
+    for entry in entries:
+        if isinstance(entry, BranchSummaryEntry) and not entry.from_hook and entry.details:
+            details = entry.details
+            if isinstance(details, dict):
+                for f in details.get("read_files", []):
+                    file_ops.read.add(f)
+                for f in details.get("modified_files", []):
+                    file_ops.edited.add(f)
+
+    # Second pass: walk newest→oldest, collect messages within budget
+    for entry in reversed(entries):
+        message = _get_message_from_entry(entry)
+        if not message:
+            continue
+
+        _extract_file_ops_from_message(message, file_ops)
+        tokens = estimate_tokens(message)
+
+        if token_budget > 0 and total_tokens + tokens > token_budget:
+            from tau.session.types import CompactionEntry
+            if isinstance(entry, (CompactionEntry, BranchSummaryEntry)):
+                if total_tokens < token_budget * 0.9:
+                    messages.insert(0, message)
+                    total_tokens += tokens
+            break
+
+        messages.insert(0, message)
+        total_tokens += tokens
+
+    return BranchPreparation(messages=messages, file_ops=file_ops, total_tokens=total_tokens)
+
+
+# ---------------------------------------------------------------------------
+# File list formatting
+# ---------------------------------------------------------------------------
+
+def _compute_file_lists(file_ops: FileOperations) -> tuple[list[str], list[str]]:
+    modified = file_ops.edited | file_ops.written
+    read_only = sorted(f for f in file_ops.read if f not in modified)
+    modified_files = sorted(modified)
+    return read_only, modified_files
+
+
+def _format_file_operations(read_files: list[str], modified_files: list[str]) -> str:
+    sections: list[str] = []
+    if read_files:
+        sections.append(f"<read-files>\n{chr(10).join(read_files)}\n</read-files>")
+    if modified_files:
+        sections.append(f"<modified-files>\n{chr(10).join(modified_files)}\n</modified-files>")
+    if not sections:
+        return ""
+    return "\n\n" + "\n\n".join(sections)
+
+
+# ---------------------------------------------------------------------------
+# Prompts
+# ---------------------------------------------------------------------------
+
+BRANCH_SUMMARY_PREAMBLE = (
+    "The user explored a different conversation branch before returning here.\n"
+    "Summary of that exploration:\n\n"
+)
+
+BRANCH_SUMMARY_PROMPT = """\
+Create a structured summary of this conversation branch for context when returning later.
+
+Use this EXACT format:
+
+## Goal
+[What was the user trying to accomplish in this branch?]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Work that was started but not finished]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [What should happen next to continue this work]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages."""
+
+
+# ---------------------------------------------------------------------------
+# Summary generation
+# ---------------------------------------------------------------------------
+
+async def generate_branch_summary(
+    entries: list[Any],
+    llm: TextLLM,
+    context_window: int = 128_000,
+    reserve_tokens: int = 16_384,
+    custom_instructions: str | None = None,
+    replace_instructions: bool = False,
+) -> BranchSummaryResult:
+    """Generate a summary of abandoned branch entries."""
+    from tau.session.compaction import serialize_conversation, SUMMARIZATION_SYSTEM_PROMPT
+    from tau.message.types import UserMessage
+    from tau.inference.types import TextEndEvent, TextDeltaEvent, LLMContext
+
+    token_budget = context_window - reserve_tokens
+    prep = prepare_branch_entries(entries, token_budget)
+
+    if not prep.messages:
+        return BranchSummaryResult(summary="No content to summarize")
+
+    conversation_text = serialize_conversation(prep.messages)
+
+    if replace_instructions and custom_instructions:
+        instructions = custom_instructions
+    elif custom_instructions:
+        instructions = f"{BRANCH_SUMMARY_PROMPT}\n\nAdditional focus: {custom_instructions}"
+    else:
+        instructions = BRANCH_SUMMARY_PROMPT
+
+    prompt_text = f"<conversation>\n{conversation_text}\n</conversation>\n\n{instructions}"
+
+    context = LLMContext(
+        messages=[UserMessage.from_text(prompt_text)],
+        system_prompt=SUMMARIZATION_SYSTEM_PROMPT,
+    )
+    events = await llm.invoke(context)
+
+    text_end = next((e for e in events if isinstance(e, TextEndEvent)), None)
+    if text_end:
+        raw = text_end.text.content
+    else:
+        raw = "".join(e.text.content for e in events if isinstance(e, TextDeltaEvent))
+
+    summary = BRANCH_SUMMARY_PREAMBLE + raw
+
+    read_files, modified_files = _compute_file_lists(prep.file_ops)
+    summary += _format_file_operations(read_files, modified_files)
+
+    return BranchSummaryResult(
+        summary=summary or "No summary generated",
+        read_files=read_files,
+        modified_files=modified_files,
+    )