sofias-sdk-lite 0.1.4__tar.gz → 0.1.5__tar.gz

{sofias_sdk_lite-0.1.4 → sofias_sdk_lite-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sofias-sdk-lite
-Version: 0.1.4
+Version: 0.1.5
 Summary: Build agents on the Sofias agent graph and run them over RabbitMQ.
 License-Expression: Apache-2.0
 Requires-Dist: pydantic>=2.0

{sofias_sdk_lite-0.1.4 → sofias_sdk_lite-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sofias-sdk-lite"
-version = "0.1.4"
+version = "0.1.5"
 description = "Build agents on the Sofias agent graph and run them over RabbitMQ."
 readme = "README.md"
 requires-python = ">=3.11"

{sofias_sdk_lite-0.1.4 → sofias_sdk_lite-0.1.5}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sofias-sdk-lite"
-version = "0.1.4"
+version = "0.1.5"
 description = "Build agents on the Sofias agent graph and run them over RabbitMQ."
 readme = "README.md"
 requires-python = ">=3.11"

{sofias_sdk_lite-0.1.4 → sofias_sdk_lite-0.1.5}/src/sofias_sdk_lite/nodes/llm_node.py

@@ -580,6 +580,61 @@ class LLMNode(BaseNode):
         all_specs = static_specs + registry_specs
         return all_specs if all_specs else None
 
+    def _tool_catalog_revision(self) -> int:
+        """Cheap read of the tool catalog's state.
+
+        Returns:
+            An integer that moves when the catalog may have changed; 0 when
+            the registry does not keep count (custom registries, test doubles).
+        """
+        rev = getattr(self._tool_registry, "revision", 0)
+        return rev if isinstance(rev, int) else 0
+
+    async def _refresh_tool_catalog(
+        self,
+        seen_revision: int,
+        tool_specs: list[ToolSpec] | None,
+        base_prompt: str,
+        prompt: str,
+        runtime_vars: dict[str, Any],
+    ) -> tuple[int, list[ToolSpec] | None, str]:
+        """Re-read the tools when the catalog changed mid-turn.
+
+        Specs used to be resolved once, before the loop, so a tool could never
+        widen the catalog for later iterations: the model never saw what it
+        had just loaded. For callers that do not use this the cost is one
+        integer comparison per iteration.
+
+        Args:
+            seen_revision: Revision the current specs were resolved at.
+            tool_specs: Current specs.
+            base_prompt: Prompt as the node's assembler produced it, before
+                the registry rebuild. Re-assembling the already rebuilt one
+                would duplicate the schemas inside the text.
+            prompt: Current prompt.
+            runtime_vars: Template variables for this turn.
+
+        Returns:
+            Updated ``(revision, specs, prompt)``, or the ones received when
+            nothing changed.
+        """
+        revision = self._tool_catalog_revision()
+        if revision == seen_revision:
+            return seen_revision, tool_specs, prompt
+
+        new_specs = await self._get_merged_tool_specs()
+        logger.info(
+            "Tool catalog refreshed",
+            node_name=self.name,
+            tools_before=len(tool_specs) if tool_specs else 0,
+            tools_after=len(new_specs) if new_specs else 0,
+        )
+        return (
+            revision,
+            new_specs,
+            self._prompt_with_registry_tools(base_prompt, new_specs, runtime_vars),
+        )
+
     def _prompt_with_registry_tools(
         self,
         prompt: str,
@@ -928,7 +983,9 @@ class LLMNode(BaseNode):
         max_iterations = self._get_max_iterations()
         parallel_tool_calls = self._get_parallel_tool_calls()
         tool_specs = await self._get_merged_tool_specs()
+        tool_catalog_revision = self._tool_catalog_revision()
 
+        base_prompt = prompt
         prompt = self._prompt_with_registry_tools(prompt, tool_specs, runtime_vars)
 
         history: list[tuple[LLMResponse, list[ToolResult]]] = []
@@ -940,6 +997,10 @@ class LLMNode(BaseNode):
         all_skipped_batches = 0
 
         while iteration < max_iterations:
+            tool_catalog_revision, tool_specs, prompt = await self._refresh_tool_catalog(
+                tool_catalog_revision, tool_specs, base_prompt, prompt, runtime_vars
+            )
+
             if token_budget and history:
                 history, fits = await self._fit_history_to_budget(
                     prompt, tool_specs, history, token_budget, token_reserve
@@ -1417,7 +1478,9 @@ class LLMNode(BaseNode):
             max_iterations = self._get_max_iterations()
             parallel_tool_calls = self._get_parallel_tool_calls()
             tool_specs = await self._get_merged_tool_specs()
+            tool_catalog_revision = self._tool_catalog_revision()
 
+            base_prompt = prompt
             prompt = self._prompt_with_registry_tools(prompt, tool_specs, runtime_vars)
 
             history: list[tuple[LLMResponse, list[ToolResult]]] = []
@@ -1440,6 +1503,10 @@ class LLMNode(BaseNode):
             )
 
             while iteration < max_iterations:
+                tool_catalog_revision, tool_specs, prompt = await self._refresh_tool_catalog(
+                    tool_catalog_revision, tool_specs, base_prompt, prompt, runtime_vars
+                )
+
                 if token_budget and history:
                     history, fits = await self._fit_history_to_budget(
                         prompt, tool_specs, history, token_budget, token_reserve

{sofias_sdk_lite-0.1.4 → sofias_sdk_lite-0.1.5}/src/sofias_sdk_lite/tools.py

@@ -336,6 +336,12 @@ class ToolProvider(Protocol):
 
     Implement this against whatever tool system you want to expose to an
     agent (MCP servers, a plugin registry, standalone functions, ...).
+
+    Optional member ``revision: int``: a provider whose catalog can change
+    mid-turn (e.g. a tool that loads a connector's tools on demand) may expose
+    a ``revision`` property that increments on every change. The node reads it
+    between tool-loop iterations and only then re-fetches the specs. Providers
+    that do not expose it behave exactly as before.
     """
 
     async def get_tools(self, node_name: str) -> list[ToolSpec]:
@@ -358,21 +364,45 @@ class ToolRegistry:
         self._provider = provider
         self._cache_tools = cache_tools
         self._tools_cache: dict[str, list[ToolSpec]] = {}
+        self._cached_at_revision: dict[str, int] = {}
+        self._revision = 0
 
     @property
     def provider(self) -> ToolProvider:
         """The underlying tool provider."""
         return self._provider
 
+    @property
+    def revision(self) -> int:
+        """Counter that moves whenever the catalog may have changed.
+
+        The node reads it between tool-loop iterations: while it stays put the
+        node reuses the specs it already has, so an agent that never touches
+        its catalog pays nothing. It moves on ``clear_cache`` and also adds the
+        provider's own ``revision`` when exposed (a cacheless provider can
+        change tools without going through ``clear_cache``). Only comparing
+        two reads is meaningful.
+        """
+        provider_revision = getattr(self._provider, "revision", 0)
+        return self._revision + (provider_revision if isinstance(provider_revision, int) else 0)
+
     async def get_tools_for_node(self, node_name: str) -> list[ToolSpec]:
         """Get tools available for a specific node, caching if enabled."""
-        if self._cache_tools and node_name in self._tools_cache:
+        # A revision different from the one cached at means the provider
+        # changed its catalog on its own: the cached list is stale.
+        revision = self.revision
+        if (
+            self._cache_tools
+            and node_name in self._tools_cache
+            and self._cached_at_revision.get(node_name) == revision
+        ):
             return self._tools_cache[node_name]
 
         try:
             tools = await self._provider.get_tools(node_name)
             if self._cache_tools:
                 self._tools_cache[node_name] = tools
+                self._cached_at_revision[node_name] = revision
             logger.debug(
                 "Loaded tools for node",
                 node_name=node_name,
@@ -396,11 +426,18 @@ class ToolRegistry:
             raise
 
     def clear_cache(self, node_name: str | None = None) -> None:
-        """Clear the tools cache, for one node or entirely."""
+        """Clear the tools cache, for one node or entirely.
+
+        Moves ``revision``, which is how the node learns the catalog changed
+        and re-fetches the specs on its next iteration.
+        """
         if node_name is not None:
             self._tools_cache.pop(node_name, None)
+            self._cached_at_revision.pop(node_name, None)
         else:
             self._tools_cache.clear()
+            self._cached_at_revision.clear()
+        self._revision += 1
 
     def get_cached_tools(self, node_name: str) -> list[ToolSpec] | None:
         """Get cached tools for a node without fetching."""