xdog-coding 2.0.1__tar.gz → 2.1.0__tar.gz

{xdog_coding-2.0.1 → xdog_coding-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: xdog-coding
-Version: 2.0.1
+Version: 2.1.0
 Summary: Interactive coding agent CLI
 Project-URL: Homepage, https://xdog.942295.xyz
 Project-URL: Repository, https://github.com/litterzhang/x-dog
@@ -21,9 +21,9 @@ Requires-Python: >=3.12
 Requires-Dist: click>=8.1.0
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pyyaml>=6.0
-Requires-Dist: xdog-agent
-Requires-Dist: xdog-ai
-Requires-Dist: xdog-tui
+Requires-Dist: xdog-agent>=2.1.0
+Requires-Dist: xdog-ai>=2.1.0
+Requires-Dist: xdog-tui>=2.1.0
 Description-Content-Type: text/markdown
 
 # xdog-coding

{xdog_coding-2.0.1 → xdog_coding-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "xdog-coding"
-version = "2.0.1"
+version = "2.1.0"
 description = "Interactive coding agent CLI"
 requires-python = ">=3.12"
 classifiers = [
@@ -21,9 +21,9 @@ readme = "README.md"
 license = "AGPL-3.0-or-later"
 license-files = ["LICENSE", "LICENSE-EXCEPTION.md"]
 dependencies = [
-    "xdog-ai",
-    "xdog-agent",
-    "xdog-tui",
+    "xdog-ai>=2.1.0",
+    "xdog-agent>=2.1.0",
+    "xdog-tui>=2.1.0",
     "pyyaml>=6.0",
     "click>=8.1.0",
     "pydantic>=2.0",

{xdog_coding-2.0.1 → xdog_coding-2.1.0}/src/xdog/coding/core/agent_session.py

@@ -94,10 +94,14 @@ class AgentSession:
         what the format's reference clients do, and it is a one-way door: a
         message cannot be taken back out of a conversation, so the body keeps
         occupying the window for the rest of the session whether or not it is
-        still relevant. The system prompt is rebuilt before every turn, so
-        putting it there makes deactivation possible at all.
+        still relevant. Keeping it in the system prompt is what makes
+        deactivation possible at all.
+
+        `Agent.set_skills` does the placing, so that reasoning now lives in one
+        place instead of being re-derived by every product that has skills.
         """
         self._active_skills = self._active_skills | {slug}
+        self._push_skills()
         self._rebuild_system_prompt()
 
     def deactivate_skill(self, slug: str) -> bool:
@@ -105,6 +109,7 @@ class AgentSession:
         if slug not in self._active_skills:
             return False
         self._active_skills = self._active_skills - {slug}
+        self._push_skills()
         self._rebuild_system_prompt()
         return True
 
@@ -159,6 +164,7 @@ class AgentSession:
 
         if expired:
             self._active_skills = self._active_skills - expired
+            self._push_skills()
             self._rebuild_system_prompt()
             logger.debug("expired turn-scoped skills: %s", sorted(expired))
 
@@ -287,6 +293,33 @@ class AgentSession:
 
     # -- Internal --
 
+    def _push_skills(self) -> None:
+        """Tell the Agent which skills are active; it decides where they go.
+
+        The index and the bodies are both its business now — this only says
+        *which*, which is the part a product legitimately differs on.
+        """
+        try:
+            self.agent.set_active_skills(sorted(self._active_skills))
+        except Exception:
+            logger.debug("could not push active skills to the agent", exc_info=True)
+
+    def _native_tool_calls(self) -> bool:
+        """Whether this model gets tool definitions through the API.
+
+        Reads the same answer the Agent uses to decide whether to send them, so
+        the two cannot disagree — a model whose tools are withheld from the API
+        while the prompt stays silent about them has no tools at all, and
+        nothing would report that.
+
+        Unknown answers False, so the tools stay described. Both halves then
+        fire, which wastes a few hundred tokens and cannot leave the model
+        unable to act.
+        """
+        from xdog.agent.helpers import model_supports_tool_calls
+
+        return model_supports_tool_calls(self.agent.state.model or "") is True
+
     def _rebuild_system_prompt(self) -> None:
         """Rebuild and set the system prompt from config and tools."""
         from xdog.coding.config import PlatformInfo, RuntimeConfig
@@ -310,6 +343,7 @@ class AgentSession:
             ),
             tool_defs,
             extra_context=_skills_context(self._active_skills),
+            native_tool_calls=self._native_tool_calls(),
         )
         self.agent.set_system_prompt(prompt)
 
@@ -356,16 +390,14 @@ def _skills_context(active: frozenset[str] = frozenset()) -> str:
     read is not a reason to start without a system prompt.
     """
     try:
-        from xdog.agent.skills import render_skill_body
         from xdog.coding.core.slash_commands import skill_manager
 
         manager = skill_manager()
         summary = manager.skills_summary()
-        bodies = []
-        for slug in sorted(active):
-            skill = manager.load_skill(slug)
-            if skill is not None:
-                bodies.append(f"## Active skill: {skill.name}\n\n{render_skill_body(skill)}")
+        # Bodies are the Agent's to place (`set_skills`); this section carries
+        # only the standing note about them. Rendering them here as well was how
+        # three packages ended up with three answers to the same question.
+        bodies = ["(active: " + ", ".join(sorted(active)) + ")"] if active else []
     except Exception:
         logger.debug("could not build the skills section of the system prompt", exc_info=True)
         return ""

{xdog_coding-2.0.1 → xdog_coding-2.1.0}/src/xdog/coding/core/sdk.py

@@ -7,6 +7,11 @@ and session management.
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from xdog.agent.skills import SkillManager
+
 import logging
 from dataclasses import dataclass
 from pathlib import Path
@@ -149,19 +154,23 @@ def create_agent_session(options: CreateSessionOptions | None = None) -> CreateS
 
     # Create Agent with explicit stream_fn from provider
     from xdog.agent import AgentConfig
-    from xdog.agent.helpers import stream_fn_from_provider
+    from xdog.agent.helpers import model_supports_tool_calls, stream_fn_from_provider
     from xdog.ai.types import StreamOptions
 
     agent = Agent(
         stream_fn_from_provider(provider),
         config=AgentConfig(
             model=model_id,
+            supports_tool_calls=model_supports_tool_calls(model_id),
             system_prompt="",  # will be rebuilt on first prompt
             options=StreamOptions(
                 thinking=_as_thinking_level(thinking_level),
             ),
         ),
         tools=agent_tools,
+        # The Agent owns where the index and the bodies go; this only says which
+        # manager to read them from.
+        skills=_coding_skill_manager(),
     )
 
     # Restore messages if resuming
@@ -183,3 +192,20 @@ def create_agent_session(options: CreateSessionOptions | None = None) -> CreateS
         session=session,
         model_fallback_message=model_fallback_message,
     )
+
+
+def _coding_skill_manager() -> "SkillManager | None":
+    """coding's SkillManager, or None if it cannot be built.
+
+    Skills are a convenience; failing to read them must not stop a session from
+    starting, which is why this swallows rather than raises.
+    """
+    try:
+        from xdog.coding.core.slash_commands import skill_manager
+
+        return skill_manager()
+    except Exception:  # pragma: no cover - defensive
+        import logging
+
+        logging.getLogger(__name__).debug("no skill manager available", exc_info=True)
+        return None

{xdog_coding-2.0.1 → xdog_coding-2.1.0}/src/xdog/coding/core/system_prompt.py

@@ -81,6 +81,7 @@ def build_system_prompt(
     *,
     file_entries: list[dict[str, Any]] | None = None,
     extra_context: str = "",
+    native_tool_calls: bool = False,
 ) -> str:
     """Assemble the complete system prompt.
 
@@ -94,12 +95,23 @@ def build_system_prompt(
         Optional processed file context entries.
     extra_context:
         Optional extra text appended at the end.
+    native_tool_calls:
+        True when the model receives tool definitions through the API, in which
+        case describing them again in the prompt sends every name, description
+        and parameter schema twice.
+
+        Defaults to False — *describe them* — because the two mistakes are not
+        symmetric. Describing tools to a model that already has them wastes
+        tokens in a cached prefix; omitting them for a model that has no other
+        way to see them leaves it unable to act, and that failure looks like the
+        model being useless rather than like a missing section.
     """
     sections: list[str] = [
         SYSTEM_PROMPT_HEADER,
         build_environment_section(config),
-        build_tool_section(tools),
     ]
+    if not native_tool_calls:
+        sections.append(build_tool_section(tools))
 
     if config.custom_instructions:
         sections.append(

{xdog_coding-2.0.1 → xdog_coding-2.1.0}/tests/test_slash_skills.py

@@ -243,7 +243,15 @@ def test_parse_slash_command_splits_name_from_arguments() -> None:
 def test_the_system_prompt_gains_and_loses_the_body(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    """Deactivation has to leave no trace, or `/unload` is theatre."""
+    """Deactivation has to leave no trace, or `/unload` is theatre.
+
+    Asserted against the Agent's system prompt rather than against the section
+    coding builds: the body is placed by `Agent.set_skills` now, so the section
+    is no longer where it lands. Checking what the model actually receives is
+    the better test anyway — it survives the placement moving again.
+    """
+    from xdog.agent.agent import Agent
+    from xdog.agent.core import AgentConfig
     from xdog.coding.core.agent_session import _skills_context
 
     shared = tmp_path / "skills"
@@ -256,11 +264,21 @@ def test_the_system_prompt_gains_and_loses_the_body(
     assert "write a workflow" in idle, "the one-line description is always advertised"
     assert "STEP ONE" not in idle, "the body must wait to be asked for"
 
-    active = _skills_context(frozenset({"flow"}))
-    assert "STEP ONE: validate the graph." in active
+    agent = Agent(
+        lambda *a, **k: None,
+        config=AgentConfig(model="m", system_prompt="BASE"),
+        skills=manager,
+    )
+    idle_prompt = agent.state.system_prompt
+    assert "write a workflow" in idle_prompt, "the index is always there"
+    assert "STEP ONE" not in idle_prompt, "the body waits to be asked for"
+
+    agent.set_active_skills(["flow"])
+    assert "STEP ONE: validate the graph." in agent.state.system_prompt
+    assert agent.state.system_prompt.strip().endswith("BASE"), "the caller's prompt survives"
 
-    # ...and back again, byte for byte.
-    assert _skills_context(frozenset()) == idle
+    agent.set_active_skills([])
+    assert agent.state.system_prompt == idle_prompt, "byte for byte, or /unload is theatre"
 
 
 def test_the_skills_section_is_empty_when_nothing_is_installed(
@@ -295,10 +313,15 @@ class FakeExpiringSession:
     def __init__(self, active: set[str]) -> None:
         self._active_skills = frozenset(active)
         self.rebuilds = 0
+        self.pushed: list[list[str]] = []
 
     def _rebuild_system_prompt(self) -> None:
         self.rebuilds += 1
 
+    def _push_skills(self) -> None:
+        """Expiry must tell the Agent too, or the body outlives the scope."""
+        self.pushed.append(sorted(self._active_skills))
+
 
 def _expire(session: Any) -> None:
     from xdog.coding.core.agent_session import AgentSession
@@ -387,3 +410,60 @@ def test_the_model_is_told_it_may_suggest_but_not_unload(
     assert "cannot deactivate" in prompt
     assert "/unload" in prompt
     assert "the user decides" in prompt.lower()
+
+
+# -- tool definitions were being sent twice ---------------------------------
+
+
+def _cfg(model: str = "copilot/x"):
+    from xdog.coding.config import PlatformInfo, RuntimeConfig
+
+    return RuntimeConfig(
+        model=model, thinking_level="normal", allowed_tools=("read",),
+        custom_instructions="", extensions=(), working_dir="/tmp",
+        platform_info=PlatformInfo.detect(),
+    )
+
+
+_TOOLS = [{"name": "read", "description": "Read a file", "parameters": {"path": "string"}}]
+
+
+def test_a_native_tool_calling_model_is_not_told_its_tools_twice() -> None:
+    """They already arrive as structured tool definitions through the API.
+    Describing them again sends every name, description and parameter schema a
+    second time, in the cached prefix, for a model that did not need it."""
+    from xdog.coding.core.system_prompt import build_system_prompt
+
+    described = build_system_prompt(_cfg(), _TOOLS, native_tool_calls=False)
+    native = build_system_prompt(_cfg(), _TOOLS, native_tool_calls=True)
+
+    assert "Read a file" in described
+    assert "Read a file" not in native
+    assert len(native) < len(described)
+
+
+def test_the_default_keeps_tools_visible() -> None:
+    """The two mistakes are not symmetric. A duplicate costs tokens; a model
+    that cannot see its tools cannot act, and that reads as the model being
+    useless rather than as a missing prompt section — so unknown means describe.
+    """
+    from xdog.coding.core.system_prompt import build_system_prompt
+
+    assert "Read a file" in build_system_prompt(_cfg(), _TOOLS)
+
+
+def test_an_unresolvable_model_still_gets_its_tools_described(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The lookup fails on an unknown provider, a network problem, or an offline
+    box. Every one of those must land on 'describe them'."""
+    from xdog.agent.helpers import model_supports_tool_calls
+    from xdog.coding.core.agent_session import AgentSession
+
+    class _Unresolvable:
+        class agent:  # noqa: N801
+            class state:  # noqa: N801
+                model = "no-such-provider/no-such-model"
+
+    assert model_supports_tool_calls("no-such-provider/no-such-model") is None
+    assert AgentSession._native_tool_calls(_Unresolvable()) is False