seedcode-cli 9.1.0__py3-none-any.whl → 9.1.1__py3-none-any.whl

seedcode/__init__.py

@@ -6,7 +6,7 @@ Plant ideas. Grow code.
 # Single source of truth for the application version. Every consumer reads it:
 # the PyPI build (via [tool.hatch.version]), the CLI --version flag, the
 # Windows installer metadata, the GitHub release tag, and the WinGet manifest.
-__version__ = "9.1.0"
+__version__ = "9.1.1"
 __author__ = "Al Shahriar Sowan"
 __publisher__ = "Eagox Studio"
 # Current author/company links, surfaced by /about and the README credits.

seedcode/_default_key_template.py

@@ -1,4 +1,4 @@
-"""Embedded built-in credential for the Default provider (v9.1.0 artifact).
+"""Embedded built-in credential for the Default provider (v9.1.1 artifact).
 
 This file is NOT committed to source control. The release build generates
 ``seedcode/_default_key.py`` from the local ``.env`` (see

seedcode/app.py

@@ -33,6 +33,7 @@ from .commands.theme import pick_theme
 from .config import load_config
 from .core.agent import AgentEngine, strip_tool_blocks
 from .core.chat import ChatEngine, ChatError
+from .core.intent import Intent, classify
 from .core.lifecycle import LifecycleError, lifecycle
 from .core.models import AppConfig
 from .core.providers import (
@@ -245,9 +246,52 @@ def _guided_setup(ui: UI, config: AppConfig) -> bool:
     return config.is_configured()
 
 
-def _handle_chat(ui: UI, engine: ChatEngine, history: HistoryStore, text: str) -> None:
-    """Send a user turn to the model and stream the reply to screen."""
-    engine.add_user(text)
+def _retrieve_context(ui: UI, intent: Intent, text: str) -> str:
+    """Fetch fresh external information for a research request (v9.1.1).
+
+    Returns a bounded context block, or '' when retrieval is disabled, fails,
+    or finds nothing. The caller shows a lightweight status and continues — a
+    failed lookup must never stop the answer. Nothing here is fatal.
+    """
+    try:
+        from .core import internet
+
+        if internet.internet_disabled():
+            return ""
+        ui.dim("[Accessing internet...]")
+        result = internet.research(intent.target or text)
+        if not result.ok:
+            ui.dim("[No online sources available]")
+            return ""
+        if result.excerpts:
+            ui.dim("[Reading relevant sources...]")
+        return internet.context_block(result)
+    except Exception:  # retrieval must never break a turn
+        _log.exception("internet retrieval failed")
+        return ""
+
+
+def _handle_chat(
+    ui: UI,
+    engine: ChatEngine,
+    history: HistoryStore,
+    text: str,
+    intent: Intent | None = None,
+) -> None:
+    """Send a user turn to the model and stream the reply to screen.
+
+    When the request needs current information, only a lightweight status is
+    shown (``[Accessing internet...]`` / ``[Reading relevant sources...]``)
+    and the retrieved sources are prepended to the turn; the browsing itself
+    is never exposed line by line.
+    """
+    resolved = intent or classify(text)
+    outgoing = text
+    if resolved.needs_internet:
+        block = _retrieve_context(ui, resolved, text)
+        if block:
+            outgoing = block + "\n\n" + text
+    engine.add_user(outgoing)
     renderer = None
     try:
         chunks = engine.stream_reply()
@@ -875,12 +919,24 @@ def _make_agent(
     return engine
 
 
+# The process-wide dangerous-action gate (v9.1.1). It is created once, not
+# once per engine: the agent engine is rebuilt whenever the permission level or
+# workspace changes, and re-creating the gate there was resetting the user's
+# "Allow" / "Allow All" answers mid-task — the repeated-permission-prompt bug.
+# A grant now survives every tool call, every multi-step task and every engine
+# rebuild, exactly as the session-scope answer promises.
+_ACTION_GATE = None
+_ACTION_GATE_LOCK = threading.Lock()
+
+
 def _make_action_gate(ui: UI):
-    """Dangerous-action gate wired to the interactive permission dialog.
+    """The session-scoped dangerous-action gate (created once per process).
 
-    Note: the Assist engine (and thus this gate) is rebuilt on permission-mode
-    changes, so session "Always" grants reset then — conservative on purpose.
+    Answers stick for the rest of the session: ``Always Allow`` per category,
+    and ``Allow All`` across every category. Nothing is persisted to disk, so
+    a new process starts clean — the scope is deliberately session-only.
     """
+    global _ACTION_GATE
     from .tools.permissions import ACTION_LABELS, ActionGate, ActionGrant
 
     def confirm(category: str, description: str) -> ActionGrant:
@@ -889,9 +945,20 @@ def _make_action_gate(ui: UI):
         return {
             "y": ActionGrant.ONCE,
             "a": ActionGrant.ALWAYS,
+            "A": ActionGrant.ALL,
         }.get(answer, ActionGrant.DENY)
 
-    return ActionGate(confirm=confirm)
+    with _ACTION_GATE_LOCK:
+        if _ACTION_GATE is None:
+            _ACTION_GATE = ActionGate(confirm=confirm)
+        return _ACTION_GATE
+
+
+def reset_action_gate() -> None:
+    """Forget all session grants (test isolation; also an explicit reset)."""
+    global _ACTION_GATE
+    with _ACTION_GATE_LOCK:
+        _ACTION_GATE = None
 
 
 def _make_desktop_session(ui: UI):
@@ -1020,7 +1087,11 @@ def _chat_loop(
         # span's ``finally`` returns the state machine to IDLE and the REPL
         # prompts again. A task can never end the app.
         with lifecycle().task_span():
-            if config.agent_mode:
+            intent = classify(text)
+            if config.agent_mode or intent.executes:
+                # Build (or rebuild) the Agent engine for the live config. A
+                # temporary escalation builds exactly the same engine an
+                # explicit Agent Mode turn would, so behaviour cannot diverge.
                 try:
                     from . import codemode_state as _cms
 
@@ -1035,11 +1106,21 @@ def _chat_loop(
                     agent = _make_agent(ui, config, presenter)
                     agent_perm = config.permission_mode
                     agent_codemode = codemode_now
+                if not config.agent_mode:
+                    # Chat Mode escalation: one agent turn, then back to chat.
+                    # The persistent mode is untouched.
+                    ui.dim(f"[Agent assist - {intent.reason}]")
+                    try:
+                        agent.set_intent(intent)  # type: ignore[union-attr]
+                    except Exception:
+                        pass
                 # One task flow per turn: the engine reports real activity into
                 # it, and the REPL keeps prompting when the turn ends.
                 _handle_agent(ui, agent, history, text, presenter)
+                if not config.agent_mode:
+                    ui.dim("[Temporary agent task finished - back to Chat Mode]")
             else:
-                _handle_chat(ui, engine, history, text)
+                _handle_chat(ui, engine, history, text, intent)
 
 
 def _interactive() -> bool:
@@ -1200,12 +1281,43 @@ class _TuiController:
                 self._ensure_agent()
                 _handle_agent(self.ui, self.agent, self.history, text, self.presenter)
             else:
-                _handle_chat(self.ui, self.engine, self.history, text)
+                intent = classify(text)
+                if intent.executes:
+                    # Chat Mode detected a request needing real execution:
+                    # escalate to Agent for THIS turn only, then return to
+                    # Chat. The persistent mode is never changed.
+                    self._run_escalated_turn(text, intent)
+                else:
+                    _handle_chat(self.ui, self.engine, self.history, text, intent)
         try:
             self.tui.sync_from_config(self.config)
         except Exception:
             pass
 
+    def _run_escalated_turn(self, text: str, intent: Intent) -> None:
+        """Run one Agent turn from Chat Mode, then hand control back (v9.1.1).
+
+        This is the *temporary* escalation path: the user stays in Chat Mode,
+        one request is executed with the full agent loop, and the session
+        returns to conversation. Explicit Agent Mode is unaffected and stays
+        active until the user changes it.
+        """
+        self.ui.dim(f"[Agent assist - {intent.reason}]")
+        try:
+            self._ensure_agent()
+            agent = self.agent
+            if agent is None:
+                _handle_chat(self.ui, self.engine, self.history, text, intent)
+                return
+            agent.set_intent(intent)
+            _handle_agent(self.ui, agent, self.history, text, self.presenter)
+        except Exception:  # escalation must never break the session
+            _log.exception("temporary agent escalation failed")
+            self.ui.error("The agent step could not run; answering in Chat Mode.")
+            _handle_chat(self.ui, self.engine, self.history, text, intent)
+        finally:
+            self.ui.dim("[Temporary agent task finished - back to Chat Mode]")
+
     # --- mode transitions ---------------------------------------------------
     def _mode_command(self, text: str) -> None:
         """Handle a mode-switch command from the composer — *never* inline.

seedcode/commands/doctor.py

@@ -97,6 +97,16 @@ def _run_checks(config) -> list[tuple[str, str, str]]:
         return rows  # nothing else is checkable without a provider
 
     provider.prepare(config)  # bind checks to the configured sub-backend
+    if provider.id == "default":
+        # The built-in connection needs no user key, but it can still be
+        # missing, invalid, or unavailable in this build. Report which one, so
+        # a clean install is diagnosable instead of just "not configured".
+        from ..default_api import BUILTIN_AVAILABLE, builtin_status
+
+        code, reason = builtin_status()
+        rows.append(
+            (_OK if code == BUILTIN_AVAILABLE else _FAIL, "Built-in connection", reason)
+        )
     if provider.requires_key:
         key = config.get_api_key(provider.id).strip()
         if not key:

seedcode/core/agent.py

@@ -34,6 +34,7 @@ from typing import Any, Callable
 
 from .chat import ChatEngine, ChatError
 from .identity import build_system_prompt
+from .intent import Intent, IntentKind, classify
 from .models import AppConfig, Message, ToolCallRecord, clean_values
 from .project import detect_project
 from .providers import provider_label
@@ -79,6 +80,25 @@ _AGENT_PREAMBLE = (
     "(permission mode: {mode})."
 )
 
+# Injected for a conversational request so an Agent turn does not reach for
+# tools (or the workspace) simply because they are available.
+_CONVERSATION_PREAMBLE = (
+    "\n\nCONVERSATIONAL REQUEST: the user is asking a question, not posing a "
+    "task. Answer directly and concisely from your own knowledge. Do NOT read "
+    "the workspace, do NOT run commands, and do NOT call a tool unless the "
+    "request explicitly names something that must be read or changed. "
+    "Using a tool you do not need is a failure, not thoroughness."
+)
+
+# Injected for a browser/desktop request so the agent never conflates it with
+# a coding task (and never scans the project to fulfil it).
+_COMPUTER_PREAMBLE = (
+    "\n\nCOMPUTER TASK: this request is about acting on the user's computer or "
+    "browser, not about their project. Do NOT read, search or modify workspace "
+    "files, and do NOT run project commands for it. Use only the computer / "
+    "browser capability required, then report what actually happened."
+)
+
 _CODEMODE_PREAMBLE = (
     "\n\nCODE MODE is ON: {workspace} is the project workspace and all work "
     "stays inside it. You are a persistent software-engineering agent, not a "
@@ -315,6 +335,10 @@ class AgentEngine(ChatEngine):
         # Code Mode session verifies tasks against this, never against the
         # model's own claim of success.
         self.last_evidence = TurnEvidence()
+        # The resolved need behind the turn in flight (v9.1.1). ``None`` until
+        # a turn (or an explicit :meth:`set_intent`) sets it, in which case the
+        # engine keeps the pre-9.1.1 behaviour of carrying full context.
+        self._intent: Intent | None = None
         # Code Mode gets a generous per-turn budget (the session continues the
         # task afterwards); callers may override it explicitly.
         if max_steps is not None:
@@ -324,6 +348,7 @@ class AgentEngine(ChatEngine):
         self.messages[0] = Message(role="system", content=self._system_prompt())
 
     def _system_prompt(self) -> str:
+        intent = self._intent
         desktop_section = ""
         if self._desktop_active():
             desktop_section = _desktop_prompt_section(self.permissions.level)
@@ -337,7 +362,7 @@ class AgentEngine(ChatEngine):
             workspace=self.permissions.workspace,
             mode=self.permissions.mode.label,
         )
-        if self._codemode_active():
+        if self._workspace_allowed() and self._codemode_active():
             # The behavioural instruction that makes the model a coding agent
             # (not just a chat model with tools) — previously defined but
             # never injected, so Code Mode lost its workflow guidance.
@@ -345,7 +370,17 @@ class AgentEngine(ChatEngine):
                 workspace=self.permissions.workspace
             )
             preamble += self._codemode_context()
-        preamble += self._terminal_context()
+        # v9.1.1: an intent-aware preamble keeps a conversational question from
+        # turning into a workspace sweep, and a browser task from touching the
+        # project at all. The terminal hint is only useful when the task can
+        # actually run something.
+        if intent is not None:
+            if intent.is_conversation:
+                preamble += _CONVERSATION_PREAMBLE
+            elif intent.kind is IntentKind.COMPUTER:
+                preamble += _COMPUTER_PREAMBLE
+        if intent is None or intent.needs_terminal or intent.needs_workspace:
+            preamble += self._terminal_context()
         if self._native_active():
             # The API carries the tool schemas; no manifest needed.
             instructions = _NATIVE_INSTRUCTIONS
@@ -353,13 +388,42 @@ class AgentEngine(ChatEngine):
             instructions = _TEXT_PROTOCOL_INSTRUCTIONS.format(
                 manifest=tool_manifest(self._groups())
             )
-        return (
-            base_identity
-            + preamble
-            + instructions
-            + desktop_section
-            + self._project_context()
-        )
+        project = self._project_context() if self._workspace_allowed() else ""
+        return base_identity + preamble + instructions + desktop_section + project
+
+    # --- intent (v9.1.1) ------------------------------------------------------
+    def set_intent(self, intent: Intent | None) -> None:
+        """Set the resolved need for the next turn and re-render the prompt.
+
+        A caller that already classified the request (the app layer, so Chat
+        escalation and Agent execution agree) passes the result here; otherwise
+        :meth:`run_turn` classifies the user text itself.
+        """
+        self._intent = intent
+        self.refresh_system_prompt()
+
+    @property
+    def intent(self) -> Intent | None:
+        """The intent of the turn in flight (``None`` before the first turn)."""
+        return self._intent
+
+    def _workspace_allowed(self) -> bool:
+        """Whether this turn may read the project (the minimum-tool rule).
+
+        Unknown intent (no turn yet) preserves the previous behaviour, so a
+        caller that never classifies loses nothing. Once an intent is set, a
+        conversational or computer task is not allowed workspace context — the
+        request must not cause file access it does not need.
+        """
+        if self._intent is None:
+            return True
+        return self._intent.needs_workspace
+
+    def _desktop_allowed(self) -> bool:
+        """Whether this turn may be offered the Computer Engine."""
+        if self._intent is None:
+            return True
+        return self._intent.needs_desktop
 
     def _codemode_active(self) -> bool:
         """Code Mode is a session-level toggle read lazily (no import cycle)."""
@@ -446,10 +510,27 @@ class AgentEngine(ChatEngine):
             return ""
 
     def _groups(self) -> tuple[str, ...]:
-        return ("core", "desktop") if self._desktop_active() else ("core",)
+        """The tool groups this turn may use (minimum necessary, v9.1.1).
+
+        ``core`` is always available; ``desktop`` only when the Computer Engine
+        is usable *and* the task needs it; ``web`` only when the task needs
+        current external information. A coding turn therefore never advertises
+        browser/desktop/web tools, and a browser turn never advertises web
+        search.
+        """
+        groups: list[str] = ["core"]
+        if self._desktop_active():
+            groups.append("desktop")
+        extra = self._intent.tool_groups if self._intent is not None else ()
+        for group in extra:
+            if group not in groups and group != "desktop":
+                groups.append(group)
+        return tuple(groups)
 
     def _desktop_active(self) -> bool:
         """Desktop tools are advertised only when enabled AND runnable here."""
+        if not self._desktop_allowed():
+            return False
         desktop = self.permissions.desktop
         if desktop is None or not desktop.enabled:
             return False
@@ -484,6 +565,14 @@ class AgentEngine(ChatEngine):
         evidence ``incomplete`` instead of ending a Code Mode task.
         """
         self.last_evidence = TurnEvidence()
+        # v9.1.1: understand the request before choosing anything. The intent
+        # decides which context and which tools this turn may use, so the agent
+        # never scans the workspace for a song or a browser task. Classification
+        # is deterministic, so re-classifying here agrees with a caller (the app
+        # layer) that already classified for its own escalation decision.
+        resolved = classify(user_text)
+        if resolved != self._intent:
+            self.set_intent(resolved)
         self.add_user(user_text)
         failures = 0
 

seedcode/core/chat.py

@@ -68,6 +68,11 @@ class ChatEngine:
         self.failover_enabled = bool(failover)
         #: ``(from_provider, to_provider)`` of the last failover, or None.
         self.last_switch: tuple[str, str] | None = None
+        #: Why the last failover happened (v9.1.1). A provider is never
+        #: switched silently: the classified reason is recorded here and can be
+        #: surfaced in the status/report so the user always knows what changed
+        #: and why.
+        self.last_switch_reason: str = ""
         # Build identity-aware system prompt with current provider + model
         system_content = build_system_prompt(
             provider_label(config.provider), config.model or "unspecified"
@@ -197,9 +202,9 @@ class ChatEngine:
                 # try another healthy configuration, unless output already
                 # streamed (retrying elsewhere would duplicate the reply).
                 switch = None if yielded else self._next_provider(tried)
-                health_mod.tracker().record_failure(provider_id, exc)
+                state = health_mod.tracker().record_failure(provider_id, exc).state
                 if switch is not None:
-                    self._switch_provider(switch)
+                    self._switch_provider(switch, reason=self._failover_reason(exc, state))
                     attempt = 0
                     continue
                 _log.error("request failed: %s", exc)
@@ -220,18 +225,37 @@ class ChatEngine:
             _log.exception("failover evaluation failed")
             return None
 
-    def _switch_provider(self, candidate: Candidate) -> None:
+    def _failover_reason(self, exc: BaseException, state) -> str:
+        """A short, user-safe reason for a provider switch (v9.1.1).
+
+        Distinguishes the failure classes the user cares about (rate limit,
+        network, authentication, unavailable) without leaking any credential
+        or request detail.
+        """
+        label = {
+            "rate_limited": "rate limited",
+            "authentication_error": "authentication rejected",
+            "offline": "network unreachable",
+            "temporarily_unavailable": "provider unavailable",
+            "retrying": "repeated transient errors",
+            "unknown": "request failed",
+        }.get(getattr(state, "value", str(state)), "request failed")
+        return label
+
+    def _switch_provider(self, candidate: Candidate, *, reason: str = "") -> None:
         """Switch to another provider while preserving all session state."""
         previous = self.config.provider
         self.config.provider = candidate.provider_id
         self.config.model = candidate.model
         self.last_switch = (previous, candidate.provider_id)
+        self.last_switch_reason = reason
         _log.warning(
-            "switch provider %s -> %s (model %s)",
-            previous, candidate.provider_id, candidate.model,
+            "switch provider %s -> %s (model %s) reason=%s",
+            previous, candidate.provider_id, candidate.model, reason or "unspecified",
         )
-        self.event(
-            "switching_provider",
-            f"{provider_label(previous)} → "
-            f"{provider_label(candidate.provider_id)}",
+        detail = (
+            f"{provider_label(previous)} → {provider_label(candidate.provider_id)}"
         )
+        if reason:
+            detail += f" ({reason})"
+        self.event("switching_provider", detail)