zettcode-sdk 0.4.0__tar.gz → 0.4.1__tar.gz

{zettcode_sdk-0.4.0 → zettcode_sdk-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: zettcode-sdk
-Version: 0.4.0
+Version: 0.4.1
 Summary: The documented, stable Python surface over ZettCode: sessions, runs, models, daemons
 Project-URL: Repository, https://github.com/Chang-LeHung/zettcode
 Author: Chang-LeHung

zettcode_sdk-0.4.1/pyproject.toml

@@ -0,0 +1,71 @@
+[project]
+name = "zettcode-sdk"
+description = "The documented, stable Python surface over ZettCode: sessions, runs, models, daemons"
+requires-python = ">=3.10"
+dynamic = ["version"]
+license = "MIT"
+authors = [{name = "Chang-LeHung"}]
+keywords = ["zettcode", "sdk", "agent"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
+  "Typing :: Typed",
+]
+dependencies = [
+  "zettcode-engine",
+  "zettcode-broker",
+  "zett-agent>=0.2.7,<0.3",
+  "httpx>=0.27,<1",
+]
+
+# The plugins that compose the agent. A part of the program, not a plugin: the `zettcode.plugins` group is what the
+# plugin release line looks for. They are activated by the rank `builtins.py` gives them, then by their `deps`.
+[project.entry-points."zettcode.agent"]
+skills = "zettcode.sdk.builtins:SkillResources"
+files = "zettcode.sdk.builtins:FileResources"
+coding = "zettcode.sdk.builtins:CodingTools"
+tool-output = "zettcode.sdk.builtins:ToolOutput"
+long-output = "zettcode.sdk.builtins:LongOutput"
+capabilities = "zettcode.sdk.builtins:Capabilities"
+subagents = "zettcode.sdk.builtins:Subagents"
+messaging = "zettcode.sdk.builtins:Messaging"
+shell-permission = "zettcode.sdk.builtins:ShellPermission"
+harness = "zettcode.sdk.builtins:Harness"
+session-log = "zettcode.sdk.builtins:SessionLog"
+todos = "zettcode.sdk.builtins:TodoPlan"
+usage-tracking = "zettcode.sdk.builtins:UsageTracking"
+context-tracking = "zettcode.sdk.builtins:ContextTracking"
+side-questions = "zettcode.sdk.builtins:SideQuestionBoundary"
+tool-guidelines = "zettcode.sdk.builtins:ToolGuidance"
+ask-user = "zettcode.sdk.builtins:AskUser"
+project-instructions = "zettcode.sdk.builtins:ProjectInstructions"
+skill-tool = "zettcode.sdk.builtins:SkillTool"
+mcp = "zettcode.sdk.builtins:McpTools"
+self-compaction = "zettcode.sdk.builtins:SelfCompaction"
+compaction = "zettcode.sdk.builtins:Compaction"
+
+[project.urls]
+Repository = "https://github.com/Chang-LeHung/zettcode"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+# One version for the whole repository: the engine ships the file.
+path = "../zettcode-engine/src/zettcode/version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/zettcode"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/src", "/pyproject.toml"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

{zettcode_sdk-0.4.0 → zettcode_sdk-0.4.1}/src/zettcode/sdk/builtins.py

@@ -16,15 +16,17 @@ Two rules decide how one registers:
   as a service by name, and the runtime reads it from there instead of keeping a field for it.
 
 The order of :data:`AGENT_PLUGINS` is the order the agent receives the extensions in; extensions that share a
-priority keep it, so it is the order they were listed in when the runtime did the listing. What a plugin
-builds on (the session store, the permission policy) is handed over by the runtime by name, see
+priority keep it. The loader finds the plugins through the ``zettcode.agent`` entry-point group this package
+publishes and activates them by the rank that list gives them (``Plugin.rank``), then by their ``deps``: what one
+reads from another, such as the capabilities the subagents are sized by, is a ``deps`` entry and not a position. What
+a plugin builds on (the session store, the permission policy) is handed over by the runtime by name, see
 :mod:`zettcode.engine.plugins.services`.
 """
 
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeVar
 
 from zettcode.config import ModelConfig
 from zettcode.engine.dialogue.side import SideQuestions
@@ -70,6 +72,8 @@ if TYPE_CHECKING:  # pragma: no cover - annotations only
     from zettcode.engine.plugins import Plugins
     from zettcode.engine.plugins.state import AgentBuild
 
+_P = TypeVar("_P", bound="Plugins")
+
 
 class SkillResources(Plugin):
     """The builtin ``@`` resource provider: the skills on this machine.
@@ -167,6 +171,8 @@ class Subagents(Plugin):
 
     name = "subagents"
     description = "The task tool and its profiles"
+    # Reads the capabilities the plugin below provides, so it is activated after it whatever their ranks say.
+    deps = ("capabilities",)
     setting = PluginSetting("subagent_enabled", "harness", "subagent")
 
     def activate(self, ctx: PluginContext) -> None:
@@ -569,7 +575,10 @@ class Compaction(Plugin):
         ctx.agent.register_extension(compaction)
 
 
-#: The agent-side plugins in the order the agent receives their extensions.
+#: The agent-side plugins in the order the agent receives their extensions. The distribution publishes the same list as
+#: entry points (``zettcode.agent`` in this package's ``pyproject.toml``) and the loader reads it from there; this tuple
+#: is what gives each its rank, and what a caller that loads without discovering (a test, a checkout with no installed
+#: distribution) passes as ``builtins=``. ``test_agent_parts.py`` holds the two lists together.
 AGENT_PLUGINS: tuple[Plugin[PluginContext], ...] = (
     SkillResources(),
     FileResources(),
@@ -595,14 +604,43 @@ AGENT_PLUGINS: tuple[Plugin[PluginContext], ...] = (
     Compaction(),
 )
 
+for _rank, _plugin in enumerate(AGENT_PLUGINS):
+    # One list is the order; the rank is read from it, so there is no second number to keep in step by hand.
+    type(_plugin).rank = _rank
+# The rank lives on the class, so a class listed twice would take the last index for both.
+assert len({type(plugin) for plugin in AGENT_PLUGINS}) == len(AGENT_PLUGINS), "AGENT_PLUGINS lists a class twice"
+
+#: The names of those plugins, which the program cannot run without.
+AGENT_PLUGIN_NAMES: tuple[str, ...] = tuple(plugin.name for plugin in AGENT_PLUGINS)
+
+
+def require_agent_parts(plugins: _P) -> _P:
+    """Return ``plugins``, or raise when the plugins that compose the agent were not found at all.
+
+    A failure to activate one is recorded in ``failed`` as it always was; what is refused here is an installation that
+    has none of them to activate, which would start an agent with no tools, no session log and no compaction.
+
+    Raises:
+        RequiredPluginError: One of :data:`AGENT_PLUGIN_NAMES` neither loaded nor failed.
+    """
+    from zettcode.engine.plugins.loader import RequiredPluginError
+
+    # Keyed on where a plugin came from and not on what it calls itself: ``builtins`` holds the origin of every plugin
+    # the program published, loaded or not, and a stranger that names itself ``mcp`` is not among them.
+    seen = set(plugins.builtins)
+    missing = {name: "not installed" for name in AGENT_PLUGIN_NAMES if name not in seen}
+    if missing:
+        raise RequiredPluginError(missing)
+    return plugins
+
 
 def load_agent_plugins(config: ZettCodeConfig, shared: Mapping[str, object]) -> Plugins:
-    """Load these builtins, plus the distributions a reader enabled: the loader a runtime is built with.
+    """Load the agent's plugins and the distributions a reader enabled: the loader a runtime is built with.
 
-    The engine's own default loads the installed plugins and no built-in at all, because the engine does not ship
-    this list. Whoever builds the runtime says which agent it wants: the SDK passes this, and the terminal passes
+    The engine's own default loads the installed plugins and none of the agent's, because the engine does not ship
+    them. Whoever builds the runtime says which agent it wants: the SDK passes this, and the terminal passes
     :func:`zettcode.app.plugins.loader.terminal_plugins`, which adds the plugins only a screen can hold.
     """
     from zettcode.engine.plugins import load_plugins
 
-    return load_plugins(config, builtins=AGENT_PLUGINS, shared=shared)
+    return require_agent_parts(load_plugins(config, builtins=(), shared=shared))

zettcode_sdk-0.4.0/pyproject.toml

@@ -1,45 +0,0 @@
-[project]
-name = "zettcode-sdk"
-description = "The documented, stable Python surface over ZettCode: sessions, runs, models, daemons"
-requires-python = ">=3.10"
-dynamic = ["version"]
-license = "MIT"
-authors = [{name = "Chang-LeHung"}]
-keywords = ["zettcode", "sdk", "agent"]
-classifiers = [
-  "Development Status :: 5 - Production/Stable",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.11",
-  "Programming Language :: Python :: 3.12",
-  "Programming Language :: Python :: 3.13",
-  "Programming Language :: Python :: 3.14",
-  "Programming Language :: Python :: 3.15",
-  "Typing :: Typed",
-]
-dependencies = [
-  "zettcode-engine",
-  "zettcode-broker",
-  "zett-agent>=0.2.7,<0.3",
-  "httpx>=0.27,<1",
-]
-
-[project.urls]
-Repository = "https://github.com/Chang-LeHung/zettcode"
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.version]
-# One version for the whole repository: the engine ships the file.
-path = "../zettcode-engine/src/zettcode/version.py"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/zettcode"]
-
-[tool.hatch.build.targets.sdist]
-include = ["/src", "/pyproject.toml"]
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-asyncio_mode = "auto"