Personal AI, On Personal Devices
Python
fix: unify managed-agent tool resolution (#705)
Elliot Slusky063dd8ea7566
diff --git a/src/openjarvis/agents/_stubs.py b/src/openjarvis/agents/_stubs.pyindex 3d800b40..3cbf8dbd 100644--- a/src/openjarvis/agents/_stubs.py+++ b/src/openjarvis/agents/_stubs.py@@ -57,6 +57,10 @@ class BaseAgent(ABC):agent_id: straccepts_tools: bool = False+ # Plain conversational agents may opt into the managed runtime's generic+ # function-calling loop. Specialized agents keep their own execution+ # class even when process-wide MCP tools are available.+ supports_managed_tool_fallback: bool = Falsedef __init__(self,diff --git a/src/openjarvis/agents/executor.py b/src/openjarvis/agents/executor.pyindex ed7126c5..14b70601 100644--- a/src/openjarvis/agents/executor.py+++ b/src/openjarvis/agents/executor.py@@ -2,7 +2,9 @@from __future__ import annotations+import jsonimport logging+import threadingimport timefrom typing import TYPE_CHECKING, Any@@ -14,6 +16,7 @@ from openjarvis.agents.errors import (classify_error,retry_delay,)+from openjarvis.agents.tool_resolver import resolve_agent_toolsfrom openjarvis.core.events import EventBus, EventTypeif TYPE_CHECKING:@@ -33,6 +36,32 @@ _MAX_RETRIES = 3_AGENT_TICK_DEFAULT_MODEL = "gemma4:31b"+def _tool_calls_for_storage(result: AgentResult) -> list[dict[str, Any]] | None:+ """Convert executor tool results to the managed-message storage contract."""++ calls: list[dict[str, Any]] = []+ for tool_result in result.tool_results:+ metadata = getattr(tool_result, "metadata", {}) or {}+ arguments = metadata.get("arguments", "")+ if not isinstance(arguments, str):+ try:+ arguments = json.dumps(arguments, sort_keys=True)+ except (TypeError, ValueError):+ arguments = json.dumps(str(arguments))+ calls.append(+ {+ "tool": getattr(tool_result, "tool_name", ""),+ "arguments": arguments,+ "result": getattr(tool_result, "content", "") or "",+ "success": bool(getattr(tool_result, "success", False)),+ # SSE and the frontend persist/display latency in milliseconds.+ "latency": float(getattr(tool_result, "latency_seconds", 0.0) or 0.0)+ * 1000.0,+ }+ )+ return calls or None++class AgentExecutor:"""Executes a single tick for a managed agent.@@ -51,6 +80,7 @@ class AgentExecutor:self._manager = managerself._bus = event_busself._trace_store = trace_store+ self._toolkit_local = threading.local()def set_system(self, system: Any) -> None:"""Deferred system injection — called after JarvisSystem is constructed."""@@ -63,27 +93,6 @@ class AgentExecutor:except Exception:pass # Non-critical- def _inject_tool_deps(self, tool: Any) -> None:- """Inject runtime dependencies into a tool instance.-- Mirrors SystemBuilder._inject_tool_deps (system.py:920-945)- but uses the lightweight system's references.- """- if self._system is None:- return- name = getattr(getattr(tool, "spec", None), "name", "")- if name == "llm":- if hasattr(tool, "_engine"):- tool._engine = self._system.engine- if hasattr(tool, "_model"):- tool._model = self._system.model- elif name == "retrieval" or name.startswith("memory_"):- if hasattr(tool, "_backend"):- tool._backend = getattr(self._system, "memory_backend", None)- elif name.startswith("channel_"):- if hasattr(tool, "_channel"):- tool._channel = getattr(self._system, "channel_backend", None)-def run_ephemeral(self,agent_type: str,@@ -248,7 +257,20 @@ class AgentExecutor:raise last_error or FatalError("max retries exhausted")def _invoke_agent(self, agent: dict) -> AgentResult:- """Invoke the actual agent run. Tests mock this method."""+ """Invoke one agent while owning every resource its resolver opens."""++ previous = getattr(self._toolkit_local, "current", None)+ self._toolkit_local.current = None+ try:+ return self._invoke_agent_impl(agent)+ finally:+ current = getattr(self._toolkit_local, "current", None)+ if current is not None:+ current.close()+ self._toolkit_local.current = previous++ def _invoke_agent_impl(self, agent: dict) -> AgentResult:+ """Implementation split out so the wrapper owns resolver lifetime."""from openjarvis.agents import AgentRegistryagent_type = agent.get("agent_type", "monitor_operative")@@ -257,6 +279,10 @@ class AgentExecutor:raise FatalError(f"Unknown agent type: {agent_type}")config = agent.get("config", {})+ agent_accepts_tools = bool(getattr(agent_cls, "accepts_tools", False))+ supports_tool_fallback = bool(+ getattr(agent_cls, "supports_managed_tool_fallback", False)+ )# Resolve engine + model from JarvisSystemengine = self._system.engine if self._system else None@@ -300,64 +326,88 @@ class AgentExecutor:except Exception:pass # Fall back to configured model- # Resolve tools from config via ToolRegistry- tool_names = config.get("tools", [])- if isinstance(tool_names, str):- tool_names = [t.strip() for t in tool_names.split(",") if t.strip()]+ mcp_tools: list[Any] = []+ mcp_clients: list[Any] = []+ if (+ config.get("mcp_tools", True) is not False+ and self._system is not None+ and (agent_accepts_tools or supports_tool_fallback)+ ):+ provider = getattr(+ self._system,+ "get_managed_agent_mcp_tools",+ None,+ )+ if callable(provider):+ try:+ mcp_tools, mcp_clients = provider()+ except Exception as exc:+ logger.warning("Managed-agent MCP discovery failed: %s", exc)+ else:+ mcp_tools = list(getattr(self._system, "mcp_tools", []) or [])+ mcp_clients = list(getattr(self._system, "_mcp_clients", []) or [])++ if not mcp_tools:+ try:+ from openjarvis.tools.mcp_adapter import MCPToolAdapter++ pool = (+ getattr(+ getattr(self._system, "tool_executor", None),+ "_tools",+ {},+ )+ or {}+ )+ mcp_tools = [+ tool+ for tool in pool.values()+ if isinstance(tool, MCPToolAdapter)+ ]+ except Exception:+ mcp_tools = []++ resolved_toolkit = resolve_agent_tools(+ agent,+ engine=engine,+ model=model,+ memory_backend=getattr(self._system, "memory_backend", None),+ channel_backend=getattr(self._system, "channel_backend", None),+ mcp_tools=mcp_tools,+ mcp_clients=mcp_clients,+ knowledge_db_path=getattr(self._system, "knowledge_db_path", None),+ )+ self._toolkit_local.current = resolved_toolkit+ tool_instances = resolved_toolkit.instances+ logger.info(+ "Agent %s: resolved %d tools (%s)",+ agent["name"],+ len(tool_instances),+ ", ".join(resolved_toolkit.by_name) or "none",+ )- tool_instances: list[Any] = []- if tool_names:- try:- from openjarvis.server.agent_manager_routes import (- _ensure_registries_populated,- )+ execution_agent_cls = agent_cls+ if tool_instances and not agent_accepts_tools and supports_tool_fallback:+ # Managed SSE already runs configured tools through a native+ # function-calling loop regardless of the selected class. Use the+ # same capability for immediate/scheduled ticks instead of+ # silently discarding the resolved toolkit for SimpleAgent and+ # other explicitly compatible non-tool classes.+ from openjarvis.agents.orchestrator import OrchestratorAgent- _ensure_registries_populated()- except ImportError:- pass- from openjarvis.core.registry import ToolRegistry-- for tname in tool_names:- if ToolRegistry.contains(tname):- try:- tool_cls = ToolRegistry.get(tname)- tool = tool_cls()- self._inject_tool_deps(tool)- tool_instances.append(tool)- except Exception:- logger.warning("Failed to instantiate tool %s", tname)-- # Pull tools already discovered by SystemBuilder (e.g. external MCP- # adapters) that aren't in the static ToolRegistry. Without this,- # agents declaring MCP-discovered tools in their template would- # silently fall back to natives only.- if (- self._system is not None- and getattr(self._system, "tool_executor", None) is not None- ):- mcp_pool = getattr(self._system.tool_executor, "_tools", {}) or {}- existing = {t.spec.name for t in tool_instances}- for tname in tool_names:- if tname in existing:- continue- pooled = mcp_pool.get(tname)- if pooled is not None:- tool_instances.append(pooled)-- if tool_instances:- logger.info(- "Agent %s: resolved %d/%d tools",- agent["name"],- len(tool_instances),- len(tool_names),- )+ execution_agent_cls = OrchestratorAgent+ logger.info(+ "Agent %s: %s does not accept tools; using %s for this "+ "tool-enabled tick",+ agent["name"],+ agent_cls.__name__,+ execution_agent_cls.__name__,+ )# Construct agent instanceagent_kwargs: dict[str, Any] = {}sys_prompt = config.get("system_prompt")- if sys_prompt is not None:- agent_kwargs["system_prompt"] = sys_prompt- if getattr(agent_cls, "accepts_tools", False) and tool_instances:+ if getattr(execution_agent_cls, "accepts_tools", False) and tool_instances:agent_kwargs["tools"] = tool_instances# Hand the agent our EventBus so its ToolExecutor can publish# TOOL_CALL_START/END — without this, ToolExecutor's ``self._bus``@@ -379,7 +429,7 @@ class AgentExecutor:# recall / persistence paths.import inspect- init_sig = inspect.signature(agent_cls.__init__)+ init_sig = inspect.signature(execution_agent_cls.__init__)accepts_var_kw = any(p.kind == inspect.Parameter.VAR_KEYWORDfor p in init_sig.parameters.values()@@ -388,6 +438,16 @@ class AgentExecutor:def _accepts(name: str) -> bool:return accepts_var_kw or name in init_sig.parameters+ # Unsupported kwargs used to trigger the broad TypeError fallback+ # below, which retried with a bare constructor and silently discarded+ # valid prompt/state wiring. Filter by the selected class's signature+ # before construction instead.+ if sys_prompt is not None and _accepts("system_prompt"):+ agent_kwargs["system_prompt"] = sys_prompt+ agent_kwargs = {+ name: value for name, value in agent_kwargs.items() if _accepts(name)+ }+state_kwargs: dict[str, Any] = {}if _accepts("operator_id"):state_kwargs["operator_id"] = agent["id"]@@ -404,23 +464,49 @@ class AgentExecutor:# agents, mirroring the one-shot `jarvis ask` path so they no# longer apply to CLI calls only (#376).cfg = getattr(self._system, "config", None)- if cfg is not None and _accepts("prompt_builder"):+ if _accepts("prompt_builder") and (+ cfg is not None or sys_prompt is not None+ ):from openjarvis.prompt.builder import SystemPromptBuilderstate_kwargs["prompt_builder"] = SystemPromptBuilder(- agent_template=getattr(cfg.agent, "default_system_prompt", "")- or "",- memory_files_config=cfg.memory_files,- system_prompt_config=cfg.system_prompt,+ agent_template=(+ sys_prompt+ if sys_prompt is not None+ else getattr(+ getattr(cfg, "agent", None),+ "default_system_prompt",+ "",+ )+ or ""+ ),+ memory_files_config=getattr(cfg, "memory_files", None),+ system_prompt_config=getattr(cfg, "system_prompt", None),)try:- agent_instance = agent_cls(engine, model, **agent_kwargs, **state_kwargs)- except TypeError:try:- agent_instance = agent_cls(engine, model, **agent_kwargs)+ agent_instance = execution_agent_cls(+ engine,+ model,+ **agent_kwargs,+ **state_kwargs,+ )except TypeError:- agent_instance = agent_cls(engine, model)+ try:+ agent_instance = execution_agent_cls(+ engine,+ model,+ **agent_kwargs,+ )+ except TypeError:+ agent_instance = execution_agent_cls(engine, model)+ except Exception:+ resolved_toolkit.close()+ raise++ if resolved_toolkit.mcp_clients:+ agent_instance._mcp_clients = resolved_toolkit.mcp_clients# Inject the managed-agent UUID into the agent's ToolExecutor so# emitted TOOL_CALL_START/END events carry it; the trace subscriber@@ -436,7 +522,7 @@ class AgentExecutor:agent["name"],len(tool_instances),", ".join(t.spec.name for t in tool_instances) or "none",- agent_cls.__name__,+ execution_agent_cls.__name__,)# Build input from instruction + summary_memory + pending messages.@@ -551,21 +637,24 @@ class AgentExecutor:len(input_text),)_t0 = time.time()- result = agent_instance.run(input_text, context=agent_ctx)-- # Retry once if the model returned empty content (common with- # Qwen3.5 thinking mode consuming all tokens).- if not (result.content or "").strip():- self._set_activity(- agent["id"],- "Retrying (empty response)...",- )- logger.warning(- "Agent %s: empty content, retrying once",- agent["name"],- )+ try:result = agent_instance.run(input_text, context=agent_ctx)+ # Retry once if the model returned empty content (common with+ # Qwen3.5 thinking mode consuming all tokens).+ if not (result.content or "").strip():+ self._set_activity(+ agent["id"],+ "Retrying (empty response)...",+ )+ logger.warning(+ "Agent %s: empty content, retrying once",+ agent["name"],+ )+ result = agent_instance.run(input_text, context=agent_ctx)+ finally:+ resolved_toolkit.close()+_elapsed = time.time() - _t0logger.info("Agent %s: agent.run() completed in %.1fs, "@@ -655,7 +744,11 @@ class AgentExecutor:# message keeps the complete report. The old [:2000] slices# double-truncated and cut findings off mid-sentence.self._manager.update_summary_memory(agent_id, result.content)- self._manager.store_agent_response(agent_id, result.content)+ self._manager.store_agent_response(+ agent_id,+ result.content,+ tool_calls=_tool_calls_for_storage(result),+ )# Budget enforcement (post-tick check)agent_data = self._manager.get_agent(agent_id)diff --git a/src/openjarvis/agents/orchestrator.py b/src/openjarvis/agents/orchestrator.pyindex cca03d2c..7241cb38 100644--- a/src/openjarvis/agents/orchestrator.py+++ b/src/openjarvis/agents/orchestrator.py@@ -57,6 +57,7 @@ class OrchestratorAgent(ToolUsingAgent):max_tokens: Optional[int] = None,mode: str = "function_calling",system_prompt: Optional[str] = None,+ prompt_builder: Optional[Any] = None,parallel_tools: bool = True,interactive: bool = False,confirm_callback=None,@@ -71,6 +72,7 @@ class OrchestratorAgent(ToolUsingAgent):max_tokens=max_tokens,interactive=interactive,confirm_callback=confirm_callback,+ prompt_builder=prompt_builder,)self._mode = modeself._system_prompt = system_prompt@@ -214,7 +216,11 @@ class OrchestratorAgent(ToolUsingAgent):self._emit_turn_start(input)# Build initial messages- messages = self._build_messages(input, context)+ messages = self._build_messages(+ input,+ context,+ system_prompt=self._system_prompt,+ )# Get OpenAI-format tool definitionsopenai_tools = self._executor.get_openai_tools() if self._tools else []diff --git a/src/openjarvis/agents/scheduler.py b/src/openjarvis/agents/scheduler.pyindex 157bcf40..5ac6f72e 100644--- a/src/openjarvis/agents/scheduler.py+++ b/src/openjarvis/agents/scheduler.py@@ -123,15 +123,35 @@ class AgentScheduler:self._thread.start()logger.info("Agent scheduler started")- def stop(self) -> None:- """Stop the scheduler background thread."""+ def request_stop(self) -> None:+ """Prevent new scheduled ticks without waiting for the worker."""+self._stop_event.set()if self._bus:self._bus.unsubscribe(EventType.AGENT_TICK_END, self._on_tick_event)- if self._thread is not None:- self._thread.join(timeout=10)++ def wait_stopped(self, timeout: float = 10.0) -> bool:+ """Wait for an active tick to finish, retaining live thread state."""++ thread = self._thread+ if thread is None:+ return True+ if thread is threading.current_thread():+ return False+ thread.join(timeout=timeout)+ if thread.is_alive():+ logger.warning("Agent scheduler did not stop within %.1fs", timeout)+ return False+ if self._thread is thread:self._thread = None- logger.info("Agent scheduler stopped")+ return True++ def stop(self, timeout: float = 10.0) -> None:+ """Stop dispatching and wait for the scheduler worker."""++ self.request_stop()+ if self.wait_stopped(timeout=timeout):+ logger.info("Agent scheduler stopped")def _loop(self) -> None:"""Main scheduler loop."""@@ -160,6 +180,8 @@ class AgentScheduler:]for agent_id, info in due:+ if self._stop_event.is_set():+ breakagent = self._manager.get_agent(agent_id)if agent is None or agent["status"] in ("paused",diff --git a/src/openjarvis/agents/simple.py b/src/openjarvis/agents/simple.pyindex 9af56b59..748cb5f8 100644--- a/src/openjarvis/agents/simple.py+++ b/src/openjarvis/agents/simple.py@@ -13,6 +13,7 @@ class SimpleAgent(BaseAgent):"""Single-turn agent: query -> model -> response. No tool calling."""agent_id = "simple"+ supports_managed_tool_fallback = Truedef run(self,diff --git a/src/openjarvis/agents/tool_resolver.py b/src/openjarvis/agents/tool_resolver.pynew file mode 100644index 00000000..404b92b1--- /dev/null+++ b/src/openjarvis/agents/tool_resolver.py@@ -0,0 +1,502 @@+"""Canonical managed-agent tool resolution.++Managed agents can run through streaming HTTP, immediate/scheduled ticks, or+the persistent-agent CLI. Those paths must bind the same live tool instances:+agent-type grants first, then configured native tools, then MCP adapters.+"""++from __future__ import annotations++import importlib+import logging+import sys+import weakref+from dataclasses import dataclass, field, replace+from pathlib import Path+from typing import Any, Iterable, Mapping++logger = logging.getLogger(__name__)++BROWSER_SUB_TOOLS = (+ "browser_navigate",+ "browser_click",+ "browser_type",+ "browser_screenshot",+ "browser_extract",+ "browser_axtree",+)++_MEMORY_TOOLS = frozenset(+ {"retrieval", "memory_store", "memory_search", "memory_index", "memory_retrieve"}+)+_CHANNEL_TOOLS = frozenset({"channel_send", "channel_list", "channel_status"})+++class _SpecOverrideTool:+ """Delegate execution while exposing an agent-configured OpenAI schema."""++ def __init__(self, wrapped: Any, advertised_spec: dict[str, Any]) -> None:+ self._wrapped = wrapped+ self._advertised_spec = advertised_spec++ @property+ def spec(self) -> Any:+ base = self._wrapped.spec+ function = self._advertised_spec.get("function", {})+ return replace(+ base,+ name=function.get("name", base.name),+ description=function.get("description", base.description),+ parameters=function.get("parameters", base.parameters),+ )++ def execute(self, **params: Any) -> Any:+ return self._wrapped.execute(**params)++ def to_openai_function(self) -> dict[str, Any]:+ return self._advertised_spec++ def __getattr__(self, name: str) -> Any:+ return getattr(self._wrapped, name)+++def _tool_name(tool: Any) -> str:+ try:+ return str(tool.spec.name)+ except Exception:+ return ""+++def _spec_name(spec: Mapping[str, Any]) -> str:+ function = spec.get("function")+ if not isinstance(function, Mapping):+ return ""+ name = function.get("name")+ return str(name) if name else ""+++def _openai_spec(tool: Any) -> dict[str, Any]:+ to_openai_function = getattr(tool, "to_openai_function", None)+ if callable(to_openai_function):+ try:+ advertised = to_openai_function()+ except Exception:+ logger.debug(+ "Failed to build advertised schema for tool %r; falling back "+ "to its ToolSpec",+ _tool_name(tool),+ exc_info=True,+ )+ else:+ if isinstance(advertised, Mapping) and _spec_name(advertised):+ return dict(advertised)+ logger.debug(+ "Tool %r returned an invalid advertised schema; falling back "+ "to its ToolSpec",+ _tool_name(tool),+ )++ spec = tool.spec+ return {+ "type": "function",+ "function": {+ "name": spec.name,+ "description": spec.description,+ "parameters": spec.parameters,+ },+ }+++def _close_resources(resources: tuple[Any, ...]) -> None:+ for resource in reversed(resources):+ close = getattr(resource, "close", None)+ if callable(close):+ try:+ close()+ except Exception:+ logger.debug("Failed to close resolved tool resource", exc_info=True)+++@dataclass+class ResolvedAgentTools:+ """One resolved toolkit, with views for agent loops and raw streaming."""++ instances: list[Any] = field(default_factory=list)+ extra_specs: list[dict[str, Any]] = field(default_factory=list)+ advertised_specs: list[dict[str, Any]] = field(default_factory=list)+ mcp_clients: list[Any] = field(default_factory=list)+ owned_resources: list[Any] = field(default_factory=list, repr=False)+ _closed: bool = field(default=False, init=False, repr=False)+ _finalizer: weakref.finalize = field(init=False, repr=False)++ def __post_init__(self) -> None:+ # This fallback covers exceptions anywhere after resolution, including+ # before an executor/response installs its normal explicit cleanup.+ self._finalizer = weakref.finalize(+ self,+ _close_resources,+ tuple(self.owned_resources),+ )++ @property+ def by_name(self) -> dict[str, Any]:+ return {name: tool for tool in self.instances if (name := _tool_name(tool))}++ @property+ def openai_specs(self) -> list[dict[str, Any]]:+ specs: list[dict[str, Any]] = []+ seen: set[str] = set()+ advertised = self.advertised_specs+ if not advertised:+ advertised = [*map(_openai_spec, self.instances), *self.extra_specs]+ for spec in advertised:+ name = _spec_name(spec)+ if name and name in seen:+ continue+ specs.append(spec)+ if name:+ seen.add(name)+ return specs++ def close(self) -> None:+ """Close request-local resources without touching shared MCP clients."""++ if self._closed:+ return+ self._closed = True+ self._finalizer()++ def __enter__(self) -> ResolvedAgentTools:+ return self++ def __exit__(self, *exc_info: object) -> None:+ self.close()+++def ensure_registries_populated() -> None:+ """Populate tool/channel registries, including after tests clear them."""++ from openjarvis.core.registry import ChannelRegistry, ToolRegistry++ try:+ import openjarvis.channels # noqa: F401+ except Exception:+ pass++ try:+ import openjarvis.tools # noqa: F401+ except Exception:+ pass++ browser_modules = ("openjarvis.tools.browser", "openjarvis.tools.browser_axtree")+ for module_name in browser_modules:+ try:+ importlib.import_module(module_name)+ except Exception:+ pass++ if not ChannelRegistry.keys():+ for module_name in list(sys.modules):+ if module_name.startswith(+ "openjarvis.channels."+ ) and not module_name.endswith("_stubs"):+ try:+ importlib.reload(sys.modules[module_name])+ except Exception:+ pass++ if not ToolRegistry.keys():+ for module_name in list(sys.modules):+ if (+ module_name.startswith("openjarvis.tools.")+ and not module_name.endswith("_stubs")+ and not module_name.endswith("agent_tools")+ ):+ try:+ importlib.reload(sys.modules[module_name])+ except Exception:+ pass++ if not any(ToolRegistry.contains(name) for name in BROWSER_SUB_TOOLS):+ for module_name in browser_modules:+ module = sys.modules.get(module_name)+ if module is not None:+ try:+ importlib.reload(module)+ except Exception:+ pass+++def instantiate_registered_tool(+ tool_cls: Any,+ name: str,+ *,+ engine: Any,+ model: str,+ memory_backend: Any = None,+ channel_backend: Any = None,+) -> Any:+ """Instantiate a registry tool with its runtime dependencies."""++ if name in _MEMORY_TOOLS:+ if memory_backend is None:+ logger.warning(+ "Memory tool %r instantiated without a backend — calls will "+ "return no results.",+ name,+ )+ return tool_cls(backend=memory_backend)+ if name in _CHANNEL_TOOLS:+ if channel_backend is None:+ logger.warning(+ "Channel tool %r instantiated without a channel — calls will "+ "fail with 'No channel backend configured'.",+ name,+ )+ return tool_cls(channel=channel_backend)+ if name == "llm":+ return tool_cls(engine=engine, model=model)+ return tool_cls()+++def build_deep_research_tools(+ engine: Any,+ model: str,+ knowledge_db_path: str | Path | None = None,+) -> list[Any]:+ """Construct the live knowledge tools granted to ``deep_research``."""++ if not knowledge_db_path:+ from openjarvis.core.config import DEFAULT_CONFIG_DIR++ knowledge_db_path = DEFAULT_CONFIG_DIR / "knowledge.db"++ path = Path(knowledge_db_path)+ if not path.exists():+ return []++ from openjarvis.connectors.retriever import TwoStageRetriever+ from openjarvis.connectors.store import KnowledgeStore+ from openjarvis.tools.knowledge_search import KnowledgeSearchTool+ from openjarvis.tools.knowledge_sql import KnowledgeSQLTool+ from openjarvis.tools.scan_chunks import ScanChunksTool+ from openjarvis.tools.think import ThinkTool++ store = KnowledgeStore(str(path))+ try:+ retriever = TwoStageRetriever(store)+ return [+ KnowledgeSearchTool(retriever=retriever),+ KnowledgeSQLTool(store=store),+ ScanChunksTool(store=store, engine=engine, model=model),+ ThinkTool(),+ ]+ except Exception:+ store.close()+ raise+++def _normalized_tool_config(tool_config: Any) -> list[Any]:+ if not tool_config:+ return []+ if isinstance(tool_config, str):+ return [part.strip() for part in tool_config.split(",") if part.strip()]+ if isinstance(tool_config, Mapping):+ return [dict(tool_config)]+ try:+ return list(tool_config)+ except TypeError:+ return []+++def resolve_agent_tools(+ agent_record: Mapping[str, Any],+ *,+ engine: Any,+ model: str,+ memory_backend: Any = None,+ channel_backend: Any = None,+ mcp_tools: Iterable[Any] = (),+ mcp_clients: Iterable[Any] = (),+ knowledge_db_path: str | Path | None = None,+) -> ResolvedAgentTools:+ """Resolve the effective live toolkit for a managed agent.++ Resolution is stable and first-wins: agent-type grants take precedence+ over configured registry tools, which take precedence over MCP adapters.+ ``config["mcp_tools"] = false`` excludes MCP adapters from this agent;+ process-wide runtimes may still own connections used by other agents.+ """++ ensure_registries_populated()+ from openjarvis.core.registry import ChannelRegistry, ToolRegistry++ config = agent_record.get("config") or {}+ if not isinstance(config, Mapping):+ config = {}++ instances: list[Any] = []+ extra_specs: list[dict[str, Any]] = []+ advertised_specs: list[dict[str, Any]] = []+ owned_resources: list[Any] = []+ seen: set[str] = set()++ def add_instance(+ tool: Any,+ *,+ advertised_spec: dict[str, Any] | None = None,+ ) -> None:+ name = _tool_name(tool)+ if not name or name in seen:+ return+ instances.append(tool)+ advertised_specs.append(advertised_spec or _openai_spec(tool))+ seen.add(name)++ use_mcp = config.get("mcp_tools", True) is not False+ mcp_tool_list = list(mcp_tools) if use_mcp else []+ mcp_by_name: dict[str, Any] = {}+ for tool in mcp_tool_list:+ name = _tool_name(tool)+ if name and name not in mcp_by_name:+ mcp_by_name[name] = tool++ if agent_record.get("agent_type") == "deep_research":+ granted_tools = build_deep_research_tools(+ engine=engine,+ model=model,+ knowledge_db_path=knowledge_db_path,+ )+ owned_ids: set[int] = set()+ for tool in granted_tools:+ resource = getattr(tool, "_store", None)+ if (+ resource is not None+ and callable(getattr(resource, "close", None))+ and id(resource) not in owned_ids+ ):+ owned_resources.append(resource)+ owned_ids.add(id(resource))+ add_instance(tool)++ for entry in _normalized_tool_config(config.get("tools")):+ if isinstance(entry, Mapping):+ raw_spec = entry if isinstance(entry, dict) else dict(entry)+ name = _spec_name(raw_spec)+ if name and name in seen:+ continue++ backing_tool = None+ if name and not ChannelRegistry.contains(name):+ if ToolRegistry.contains(name):+ try:+ backing_tool = instantiate_registered_tool(+ ToolRegistry.get(name),+ name,+ engine=engine,+ model=model,+ memory_backend=memory_backend,+ channel_backend=channel_backend,+ )+ except Exception as exc:+ logger.warning(+ "Could not instantiate tool '%s' (%s) — "+ "advertising its custom spec without execution",+ name,+ exc,+ )+ elif name in mcp_by_name:+ backing_tool = mcp_by_name[name]++ if backing_tool is not None:+ add_instance(+ _SpecOverrideTool(backing_tool, raw_spec),+ advertised_spec=raw_spec,+ )+ else:+ logger.warning(+ "Custom tool spec '%s' has no registered or MCP execution "+ "backend — dropping",+ name or "<unnamed>",+ )+ continue+ if not isinstance(entry, str):+ continue++ names = BROWSER_SUB_TOOLS if entry == "browser" else (entry,)+ for name in names:+ if name in seen:+ continue+ if ChannelRegistry.contains(name):+ continue+ if not ToolRegistry.contains(name):+ logger.warning(+ "Tool '%s' referenced in agent config but not in ToolRegistry",+ name,+ )+ continue+ try:+ add_instance(+ instantiate_registered_tool(+ ToolRegistry.get(name),+ name,+ engine=engine,+ model=model,+ memory_backend=memory_backend,+ channel_backend=channel_backend,+ )+ )+ except Exception as exc:+ logger.warning(+ "Could not instantiate tool '%s' (%s) — dropping", name, exc+ )++ if use_mcp:+ for tool in mcp_tool_list:+ add_instance(tool)++ return ResolvedAgentTools(+ instances=instances,+ extra_specs=extra_specs,+ advertised_specs=advertised_specs,+ mcp_clients=list(mcp_clients) if use_mcp else [],+ owned_resources=owned_resources,+ )+++def resolve_tool_specs(tool_config: Any) -> list[dict[str, Any]]:+ """Compatibility view for callers that only need configured specs."""++ specs: list[dict[str, Any]] = []+ seen: set[str] = set()+ for entry in _normalized_tool_config(tool_config):+ if isinstance(entry, dict):+ specs.append(entry)+ name = _spec_name(entry)+ if name:+ seen.add(name)+ continue+ resolved = resolve_agent_tools(+ {"config": {"tools": [entry]}},+ engine=None,+ model="",+ )+ for spec in resolved.openai_specs:+ name = _spec_name(spec)+ if name and name in seen:+ continue+ specs.append(spec)+ if name:+ seen.add(name)+ return specs+++__all__ = [+ "BROWSER_SUB_TOOLS",+ "ResolvedAgentTools",+ "build_deep_research_tools",+ "ensure_registries_populated",+ "instantiate_registered_tool",+ "resolve_agent_tools",+ "resolve_tool_specs",+]diff --git a/src/openjarvis/cli/serve.py b/src/openjarvis/cli/serve.pyindex 6c9e415a..a9e346a3 100644--- a/src/openjarvis/cli/serve.py+++ b/src/openjarvis/cli/serve.py@@ -279,6 +279,15 @@ def serve(# (which would re-discover the engine, re-resolve tools, re-open the channel,# etc.). See the scheduler block near the bottom of this function (#263).resolved_tools: list = []+ managed_mcp_tools: list = []+ mcp_clients: list = []+ try:+ from openjarvis.mcp.loader import load_mcp_tools_from_config++ managed_mcp_tools, mcp_clients = load_mcp_tools_from_config(config.tools.mcp)+ except Exception as exc:+ logger.warning("Managed-agent MCP tools failed to load: %s", exc)+if agent_key:try:import openjarvis.agents # noqa: F401@@ -290,11 +299,6 @@ def serve(if sec.capability_policy is not None:agent_kwargs["capability_policy"] = sec.capability_policy- # MCP transports persisted on the agent at the bottom of- # this block — initialise here so the reference is valid- # even when accepts_tools is False (#461).- mcp_clients: list = []-# Load tools for agents that support themif getattr(agent_cls, "accepts_tools", False):import openjarvis.tools # noqa: F401 # trigger registration@@ -331,12 +335,13 @@ def serve(# MCP server tools from config.tools.mcp.servers# (#461 — these were silently dropped).- from openjarvis.mcp.loader import load_mcp_tools_from_config-- mcp_tools, mcp_clients = load_mcp_tools_from_config(- config.tools.mcp,- allowed_names=allowed if configured else None,- )+ mcp_tools = managed_mcp_tools+ if configured:+ mcp_tools = [+ tool+ for tool in managed_mcp_tools+ if tool.spec.name in allowed+ ]if mcp_tools:existing = {t.spec.name for t in tools}for t in mcp_tools:@@ -389,10 +394,6 @@ def serve(channel_agent = config.channel.default_agent or agent_key or "simple"_channel_tools: list = []- # MCP transports persisted at function scope (= server-process- # lifetime); see the comment near the channel-MCP-load block- # below. Initialise here so it's always bound. #461.- _channel_mcp_clients: list = []if channel_agent:try:import openjarvis.agents@@ -432,29 +433,23 @@ def serve(elif isinstance(_tcls, BaseTool):_channel_tools.append(_tcls)- # MCP tools for the channel agent too (#461).- from openjarvis.mcp.loader import (- load_mcp_tools_from_config,- )-- _ch_mcp_tools, _ch_mcp_clients = load_mcp_tools_from_config(- config.tools.mcp,- allowed_names=_allowed if configured else None,- )+ # Reuse the process-owned MCP pool so channels do not+ # open a second transport to every configured server.+ _ch_mcp_tools = managed_mcp_tools+ if configured:+ _ch_mcp_tools = [+ tool+ for tool in managed_mcp_tools+ if tool.spec.name in _allowed+ ]if _ch_mcp_tools:_existing = {t.spec.name for t in _channel_tools}for t in _ch_mcp_tools:if t.spec.name not in _existing:_channel_tools.append(t)_existing.add(t.spec.name)- # Hold a reference at module / function scope —- # the channel agent is constructed inside- # JarvisSystem below; we extend its lifetime by- # keeping the list bound here.- _channel_mcp_clients = _ch_mcp_clientsexcept Exception as exc:logger.warning("Channel tools failed to load: %s", exc)- _channel_mcp_clients = []_wire_system = JarvisSystem(config=config,@@ -464,6 +459,8 @@ def serve(model=model_name,agent_name=channel_agent,tools=_channel_tools,+ mcp_tools=managed_mcp_tools,+ _mcp_clients=mcp_clients,)_wire_system.wire_channel(channel_bridge)@@ -481,23 +478,24 @@ def serve(# Create appfrom openjarvis.server.app import create_app- # Set up memory backend for context injection. Built before the scheduler- # block so the executor's JarvisSystem can reference it (#263).+ # Set up the memory backend for storage tools, API routes, and optional+ # prompt-context injection. ``context_from_memory`` controls only the last+ # of those, so disabling it must not leave explicit memory_* tools with a+ # null backend. Built before the scheduler so AgentExecutor can reuse it.memory_backend = None- if config.agent.context_from_memory:- try:- import openjarvis.tools.storage # noqa: F401- from openjarvis.core.registry import MemoryRegistry-- mem_key = config.memory.default_backend- if MemoryRegistry.contains(mem_key):- memory_backend = MemoryRegistry.create(- mem_key,- db_path=config.memory.db_path,- )- console.print(" Memory: [cyan]active[/cyan]")- except Exception as exc:- logger.debug("Memory backend init failed: %s", exc)+ try:+ import openjarvis.tools.storage # noqa: F401+ from openjarvis.core.registry import MemoryRegistry++ mem_key = config.memory.default_backend+ if MemoryRegistry.contains(mem_key):+ memory_backend = MemoryRegistry.create(+ mem_key,+ db_path=config.memory.db_path,+ )+ console.print(" Memory: [cyan]active[/cyan]")+ except Exception as exc:+ logger.debug("Memory backend init failed: %s", exc)# Automatic long-term memory service (background fact extraction).memory_service = None@@ -592,6 +590,7 @@ def serve(agent=agent,agent_name=agent_key or "",tools=resolved_tools,+ mcp_tools=managed_mcp_tools,tool_executor=_sched_tool_executor,memory_backend=memory_backend,telemetry_store=telem_store,@@ -600,6 +599,7 @@ def serve(capability_policy=sec.capability_policy,agent_manager=agent_manager,agent_executor=executor,+ _mcp_clients=mcp_clients,)executor.set_system(system)@@ -691,10 +691,13 @@ def serve(channel_bridge=channel_bridge,config=config,memory_backend=memory_backend,+ own_memory_backend=memory_backend is not None,memory_service=memory_service,speech_backend=speech_backend,agent_manager=agent_manager,agent_scheduler=agent_scheduler,+ mcp_tools=managed_mcp_tools,+ mcp_clients=mcp_clients,api_key=api_key,webhook_config=webhook_config,cors_origins=config.server.cors_origins,@@ -723,6 +726,4 @@ def serve("authenticated requests to your instance.")- import uvicorn-uvicorn.run(app, host=bind_host, port=bind_port, log_level="info")diff --git a/src/openjarvis/mcp/client.py b/src/openjarvis/mcp/client.pyindex 5b495922..a18b2032 100644--- a/src/openjarvis/mcp/client.py+++ b/src/openjarvis/mcp/client.py@@ -3,6 +3,7 @@from __future__ import annotationsimport itertools+import threadingfrom typing import Any, Dict, Listfrom openjarvis.mcp.protocol import MCPError, MCPRequest, MCPResponse@@ -24,18 +25,31 @@ class MCPClient:self._initialized = Falseself._capabilities: Dict[str, Any] = {}self._id_counter = itertools.count(1)+ # A client may be shared by server, scheduled, and channel agents.+ # Keep each transport request/response exchange atomic so stdio+ # readers cannot consume another thread's JSON-RPC response.+ self._request_lock = threading.RLock()+ # Closing must not wait for ``_request_lock``: transport.close() is+ # what interrupts a request that is blocked in a transport read.+ # An event lets queued requests fail before touching that transport,+ # while this separate lock keeps close itself idempotent.+ self._closed = threading.Event()+ self._transport_closed = threading.Event()+ self._close_lock = threading.Lock()def _next_id(self) -> int:return next(self._id_counter)def _send(self, method: str, params: Dict[str, Any] | None = None) -> MCPResponse:"""Send a request and check for errors."""- request = MCPRequest(- method=method,- params=params or {},- id=self._next_id(),- )- response = self._transport.send(request)+ with self._request_lock:+ self._raise_if_closed()+ request = MCPRequest(+ method=method,+ params=params or {},+ id=self._next_id(),+ )+ response = self._transport.send(request)if response.error is not None:raise MCPError(code=response.error.get("code", -1),@@ -44,6 +58,10 @@ class MCPClient:)return response+ def _raise_if_closed(self) -> None:+ if self._closed.is_set():+ raise RuntimeError("MCP client is closed")+def initialize(self) -> Dict[str, Any]:"""Perform the MCP initialize handshake.@@ -75,7 +93,9 @@ class MCPClient:params=params or {},id=None, # None → no id field in JSON (notification))- self._transport.send_notification(request)+ with self._request_lock:+ self._raise_if_closed()+ self._transport.send_notification(request)def list_tools(self) -> List[ToolSpec]:"""Discover available tools from the server.@@ -114,7 +134,15 @@ class MCPClient:def close(self) -> None:"""Close the transport connection."""- self._transport.close()+ # Do not acquire _request_lock here. A transport request can be stuck+ # waiting for a server response, and closing the underlying transport+ # is the mechanism that unblocks it.+ with self._close_lock:+ if self._transport_closed.is_set():+ return+ self._closed.set()+ self._transport.close()+ self._transport_closed.set()def __enter__(self) -> MCPClient:return selfdiff --git a/src/openjarvis/server/agent_manager_routes.py b/src/openjarvis/server/agent_manager_routes.pyindex 5b33491c..afb4a591 100644--- a/src/openjarvis/server/agent_manager_routes.py+++ b/src/openjarvis/server/agent_manager_routes.py@@ -4,9 +4,22 @@ from __future__ import annotationsimport loggingimport re as _re+import threadingfrom typing import Any, Dict, List, Optional, Tuplefrom openjarvis.agents.manager import AgentManager+from openjarvis.agents.tool_resolver import (+ BROWSER_SUB_TOOLS as _BROWSER_SUB_TOOLS,+)+from openjarvis.agents.tool_resolver import (+ build_deep_research_tools,+ instantiate_registered_tool,+ resolve_agent_tools,+ resolve_tool_specs,+)+from openjarvis.agents.tool_resolver import (+ ensure_registries_populated as _ensure_registries_populated,+)try:from fastapi import APIRouter, HTTPException, Request@@ -16,6 +29,44 @@ except ImportError:raise ImportError("fastapi and pydantic are required for server routes")logger = logging.getLogger("openjarvis.server.agent_manager")+_MEMORY_BACKEND_LOCK_SETUP = threading.Lock()+_MCP_LOCK_SETUP = threading.Lock()+++def _start_managed_worker(app_state: Any, target: Any, *, name: str) -> Any:+ """Start and track a managed-agent worker for orderly app shutdown."""++ lock = getattr(app_state, "_managed_worker_lock", None)+ if lock is None:+ lock = threading.Lock()+ app_state._managed_worker_lock = lock+ workers = getattr(app_state, "_managed_workers", None)+ if workers is None:+ workers = set()+ app_state._managed_workers = workers++ thread: threading.Thread++ def _run() -> None:+ try:+ target()+ finally:+ with lock:+ workers.discard(thread)++ with lock:+ if getattr(app_state, "_managed_runtime_stopping", False):+ raise RuntimeError("managed-agent runtime is shutting down")+ thread = threading.Thread(target=_run, daemon=True, name=name)+ workers.add(thread)+ try:+ # Shutdown must never snapshot an added-but-not-started thread,+ # because joining such a thread raises instead of draining it.+ thread.start()+ except Exception:+ workers.discard(thread)+ raise+ return threadclass CreateAgentRequest(BaseModel):@@ -59,24 +110,15 @@ class FeedbackRequest(BaseModel):reason: Optional[str] = None-_BROWSER_SUB_TOOLS = {- "browser_navigate",- "browser_click",- "browser_type",- "browser_screenshot",- "browser_extract",- "browser_axtree",-}--def _resolve_memory_backend(config: Any) -> Any:"""Instantiate the configured memory backend, or None if unavailable.- Mirrors serve.py's setup so an agent tick that runs through the server- can actually use its memory_* tools. Returns None (so the tools degrade- gracefully) when memory context is disabled or the backend can't load.+ Memory storage is a tool dependency, independent of whether retrieved+ context is injected into prompts. ``context_from_memory`` controls only+ that prompt enrichment; explicitly configured ``memory_*`` tools still+ need a backend when it is false."""- if config is None or not getattr(config.agent, "context_from_memory", False):+ if config is None:return Nonetry:import openjarvis.tools.storage # noqa: F401@@ -90,26 +132,141 @@ def _resolve_memory_backend(config: Any) -> Any:return None+def _memory_backend_lock(app_state: Any) -> threading.Lock:+ """Return the per-runtime lock, creating it safely for lightweight tests."""++ lock = getattr(app_state, "_memory_backend_lock", None)+ if lock is not None:+ return lock+ with _MEMORY_BACKEND_LOCK_SETUP:+ lock = getattr(app_state, "_memory_backend_lock", None)+ if lock is None:+ lock = threading.Lock()+ app_state._memory_backend_lock = lock+ return lock+++def _get_or_create_memory_backend(app_state: Any, config: Any = None) -> Any:+ """Return one runtime-owned memory backend, even under concurrent ticks."""++ if app_state is None:+ return None+ backend = getattr(app_state, "memory_backend", None)+ if backend is not None:+ return backend++ lock = _memory_backend_lock(app_state)+ with lock:+ backend = getattr(app_state, "memory_backend", None)+ if backend is not None:+ return backend+ if getattr(app_state, "_managed_runtime_stopping", False):+ return None+ backend = _resolve_memory_backend(+ config if config is not None else getattr(app_state, "config", None)+ )+ if backend is not None:+ app_state.memory_backend = backend+ app_state._owns_memory_backend = True+ return backend+++def _mcp_state_lock(app_state: Any, attr: str) -> threading.Lock:+ """Return a named per-runtime MCP lock, creating it atomically."""++ lock = getattr(app_state, attr, None)+ if lock is not None:+ return lock+ with _MCP_LOCK_SETUP:+ lock = getattr(app_state, attr, None)+ if lock is None:+ lock = threading.Lock()+ setattr(app_state, attr, lock)+ return lock+++def _register_mcp_client(app_state: Any, client: Any) -> bool:+ """Publish a client before blocking I/O so shutdown can interrupt it."""++ lock = _mcp_state_lock(app_state, "_mcp_clients_lock")+ with lock:+ if getattr(app_state, "_managed_runtime_stopping", False):+ return False+ clients = getattr(app_state, "_mcp_clients", None)+ if not isinstance(clients, list):+ clients = list(clients or [])+ app_state._mcp_clients = clients+ clients.append(client)+ return True+++def _unregister_mcp_client(app_state: Any, client: Any) -> None:+ """Remove a client that failed discovery or exposed no usable tools."""++ lock = _mcp_state_lock(app_state, "_mcp_clients_lock")+ with lock:+ clients = getattr(app_state, "_mcp_clients", None)+ if isinstance(clients, list):+ try:+ clients.remove(client)+ except ValueError:+ pass++class _LightweightSystem:"""Minimal system facade for the executor — avoids rebuilding thefull JarvisSystem (which picks a random model from Ollama)."""- def __init__(self, engine: Any, model: str, config: Any = None):+ def __init__(+ self,+ engine: Any,+ model: str,+ config: Any = None,+ runtime: Any = None,+ ):self.engine = engineself.model = modelself.config = config+ self._runtime = runtime# Wire the configured memory backend so an agent's memory_store /# memory_retrieve tools work when the tick runs through the server.# The executor injects system.memory_backend into those tools; this# facade previously left it None, so they reported "No memory backend# configured" even though the backend was configured and active.- self.memory_backend = _resolve_memory_backend(config)+ self.memory_backend = _get_or_create_memory_backend(runtime, config)+ self.channel_backend = None+ self.mcp_tools: list[Any] = []+ self._mcp_clients: list[Any] = []+ self.knowledge_db_path = None+ if runtime is not None:+ self.channel_backend = getattr(runtime, "channel_backend", None) or getattr(+ runtime, "channel_bridge", None+ )+ self.knowledge_db_path = getattr(runtime, "knowledge_db_path", None)++ def get_managed_agent_mcp_tools(self) -> tuple[list[Any], list[Any]]:+ """Lazily discover MCP tools only after the agent allows them."""++ if self.mcp_tools:+ return self.mcp_tools, self._mcp_clients+ if self._runtime is None:+ return [], []++ runtime_tools = list(getattr(self._runtime, "mcp_tools", []) or [])+ if runtime_tools:+ self.mcp_tools = runtime_tools+ else:+ _, adapters = _get_mcp_tools(self._runtime)+ self.mcp_tools = list(adapters.values())+ self._mcp_clients = list(getattr(self._runtime, "_mcp_clients", []) or [])+ return self.mcp_tools, self._mcp_clientsdef _make_lightweight_system(engine: Any,model: str,config: Any = None,+ runtime: Any = None,) -> _LightweightSystem:"""Build a minimal system with a fresh inference engine.@@ -154,10 +311,10 @@ def _make_lightweight_system()except Exception:pass # telemetry is optional- return _LightweightSystem(plain_engine, model, cfg)+ return _LightweightSystem(plain_engine, model, cfg, runtime)except Exception:pass- return _LightweightSystem(engine, model, config)+ return _LightweightSystem(engine, model, config, runtime)def _parse_param_count(model_name: str) -> float:@@ -193,73 +350,6 @@ def _pick_recommended_model(}-def _ensure_registries_populated() -> None:- """Ensure ToolRegistry and ChannelRegistry are populated.-- If the registries are empty (e.g. cleared by test fixtures) but the- modules are already cached in sys.modules, reload the individual- submodules to re-execute their @register decorators.- """- import importlib- import sys-- from openjarvis.core.registry import ChannelRegistry, ToolRegistry-- # First, try a normal import (works if modules haven't been imported yet)- try:- import openjarvis.channels # noqa: F401- except Exception:- pass-- try:- import openjarvis.tools # noqa: F401- except Exception:- pass-- # Also try to import browser tools (not included in openjarvis.tools.__init__)- for _browser_mod in ("openjarvis.tools.browser", "openjarvis.tools.browser_axtree"):- try:- importlib.import_module(_browser_mod)- except Exception:- pass-- # If registries are still empty, reload individual submodules from sys.modules- if not ChannelRegistry.keys():- for mod_name in list(sys.modules):- if mod_name.startswith("openjarvis.channels.") and not mod_name.endswith(- "_stubs"- ):- try:- importlib.reload(sys.modules[mod_name])- except Exception:- pass-- if not ToolRegistry.keys():- for mod_name in list(sys.modules):- if (- mod_name.startswith("openjarvis.tools.")- and not mod_name.endswith("_stubs")- and not mod_name.endswith("agent_tools")- ):- try:- importlib.reload(sys.modules[mod_name])- except Exception:- pass-- # After reloading tools, also try browser tools if still not registered- if not any(ToolRegistry.contains(n) for n in _BROWSER_SUB_TOOLS):- for _browser_mod in (- "openjarvis.tools.browser",- "openjarvis.tools.browser_axtree",- ):- mod = sys.modules.get(_browser_mod)- if mod is not None:- try:- importlib.reload(mod)- except Exception:- pass--def build_tools_list() -> List[Dict[str, Any]]:"""Build unified tools list from ToolRegistry + ChannelRegistry."""import os@@ -347,93 +437,10 @@ def build_tools_list() -> List[Dict[str, Any]]:return items-def _resolve_tool_specs(- tool_config: Any,-) -> List[Dict[str, Any]]:- """Convert a template's ``tools`` config into OpenAI-format function specs.-- The template TOML stores tools as a list of string names (e.g.- ``["file_read", "shell_exec"]``). Engines expect OpenAI-shaped dicts:- ``{"type": "function", "function": {"name, description, parameters"}}``.-- Special handling:- * Dict entries pass through as-is (allows advanced configs to- supply fully-formed specs).- * ``browser`` is a synthetic display-only meta-tool that expands- to the 6 real browser sub-tools (browser_navigate, click, …).- * Channel names (``slack``, ``gmail``, …) come from the- ``ChannelRegistry`` and are not directly callable by the LLM —- they're destinations for ``channel_send``. Silently skip them.- * Unknown tool names are dropped with a warning.- """- if not tool_config:- return []+def _resolve_tool_specs(tool_config: Any) -> List[Dict[str, Any]]:+ """Compatibility wrapper for callers of the former route-local helper."""- from openjarvis.core.registry import ChannelRegistry, ToolRegistry-- _ensure_registries_populated()-- def _spec_dict_for(name: str) -> Optional[Dict[str, Any]]:- try:- spec = ToolRegistry.get(name)().spec- except Exception as exc:- logger.warning(- "Could not build spec for tool '%s' (%s) — dropping",- name,- exc,- )- return None- return {- "type": "function",- "function": {- "name": spec.name,- "description": spec.description,- "parameters": spec.parameters,- },- }-- resolved: List[Dict[str, Any]] = []- seen: set = set()-- for entry in tool_config:- if isinstance(entry, dict):- resolved.append(entry)- continue- if not isinstance(entry, str):- continue-- # Expand the synthetic "browser" meta-tool into its sub-tools.- if entry == "browser":- for sub in _BROWSER_SUB_TOOLS:- if sub in seen or not ToolRegistry.contains(sub):- continue- spec_dict = _spec_dict_for(sub)- if spec_dict:- resolved.append(spec_dict)- seen.add(sub)- continue-- # Channels (slack, gmail, …) live in ChannelRegistry and aren't- # callable by the LLM. Skip silently — the agent talks to them- # through the `channel_send` tool with a `channel` argument.- if ChannelRegistry.contains(entry):- continue-- if not ToolRegistry.contains(entry):- logger.warning(- "Tool '%s' referenced in agent config but not in ToolRegistry",- entry,- )- continue-- if entry in seen:- continue- spec_dict = _spec_dict_for(entry)- if spec_dict:- resolved.append(spec_dict)- seen.add(entry)-- return resolved+ return resolve_tool_specs(tool_config)# Per-agent sampler params forwarded to the engine when present in config.@@ -547,82 +554,35 @@ def _instantiate_managed_tool(model: str,app_state: Any,) -> Any:- """Instantiate a tool with the same dependency injection as the canonical- ``cli/ask.py`` path, so ``memory_*`` / ``channel_*`` / ``llm`` tools work- instead of silently failing with "No backend configured" (#395).- """- try:- from openjarvis.cli.ask import (- _CHANNEL_TOOLS,- _MEMORY_TOOLS,- _get_memory_backend,+ """Compatibility adapter for tests and non-managed route callers."""++ memory_backend = _get_or_create_memory_backend(+ app_state,+ getattr(app_state, "config", None) if app_state is not None else None,+ )+ channel_backend = None+ if app_state is not None:+ channel_backend = getattr(app_state, "channel_backend", None) or getattr(+ app_state, "channel_bridge", None)- except Exception: # pragma: no cover - cli import should always succeed- _MEMORY_TOOLS = frozenset()- _CHANNEL_TOOLS = frozenset()- _get_memory_backend = None-- if name in _MEMORY_TOOLS:- backend = getattr(app_state, "memory_backend", None) if app_state else None- if backend is None and app_state is not None and _get_memory_backend:- cfg = getattr(app_state, "config", None)- if cfg is not None:- backend = _get_memory_backend(cfg)- if backend is None:- logger.warning(- "Memory tool %r instantiated without a backend — calls will "- "return no results.",- name,- )- return tool_cls(backend=backend)- if name in _CHANNEL_TOOLS:- channel = getattr(app_state, "channel_bridge", None) if app_state else None- if channel is None:- logger.warning(- "Channel tool %r instantiated without a channel — calls will "- "fail with 'No channel backend configured'.",- name,- )- return tool_cls(channel=channel)- if name == "llm":- return tool_cls(engine=engine, model=model)- return tool_cls()+ return instantiate_registered_tool(+ tool_cls,+ name,+ engine=engine,+ model=model,+ memory_backend=memory_backend,+ channel_backend=channel_backend,+ )def _build_deep_research_tools(engine: Any,model: str,knowledge_db_path: str = "",-) -> list:- """Build the 4 DeepResearch tools from a KnowledgeStore.-- Returns an empty list if the knowledge DB does not exist.- """- from pathlib import Path-- if not knowledge_db_path:- from openjarvis.core.config import DEFAULT_CONFIG_DIR-- knowledge_db_path = str(DEFAULT_CONFIG_DIR / "knowledge.db")+) -> list[Any]:+ """Compatibility wrapper for existing channel and server integrations."""- if not Path(knowledge_db_path).exists():- return []-- from openjarvis.connectors.retriever import TwoStageRetriever- from openjarvis.connectors.store import KnowledgeStore- from openjarvis.tools.knowledge_search import KnowledgeSearchTool- from openjarvis.tools.knowledge_sql import KnowledgeSQLTool- from openjarvis.tools.scan_chunks import ScanChunksTool- from openjarvis.tools.think import ThinkTool-- store = KnowledgeStore(knowledge_db_path)- retriever = TwoStageRetriever(store)- return [- KnowledgeSearchTool(retriever=retriever),- KnowledgeSQLTool(store=store),- ScanChunksTool(store=store, engine=engine, model=model),- ThinkTool(),- ]+ return build_deep_research_tools(engine, model, knowledge_db_path)def _merge_tool_call_fragments(@@ -659,10 +619,44 @@ def _get_mcp_tools(app_state: Any) -> Tuple[List[Dict[str, Any]], Dict[str, Any]Lazily discovers MCP tools from config and caches them on ``app_state``so that subsequent requests reuse the same connections."""+ lock = _mcp_state_lock(app_state, "_mcp_discovery_lock")+ with lock:+ return _get_mcp_tools_locked(app_state)+++def _get_mcp_tools_locked(+ app_state: Any,+) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:+ """Discover MCP tools while the runtime's discovery lock is held."""++ if getattr(app_state, "_managed_runtime_stopping", False):+ return [], {}+cached = getattr(app_state, "_mcp_tools_cache", None)if cached is not None:return cached+ preloaded = list(getattr(app_state, "mcp_tools", []) or [])+ if preloaded:+ adapters_by_name: Dict[str, Any] = {}+ for tool in preloaded:+ spec = getattr(tool, "spec", None)+ if spec is not None and spec.name not in adapters_by_name:+ adapters_by_name[spec.name] = tool+ openai_tools = [+ {+ "type": "function",+ "function": {+ "name": tool.spec.name,+ "description": tool.spec.description,+ "parameters": tool.spec.parameters,+ },+ }+ for tool in adapters_by_name.values()+ ]+ app_state._mcp_tools_cache = (openai_tools, adapters_by_name)+ return app_state._mcp_tools_cache+import json as _jsonfrom openjarvis.core.config import load_config@@ -683,9 +677,6 @@ def _get_mcp_tools(app_state: Any) -> Tuple[List[Dict[str, Any]], Dict[str, Any]from openjarvis.mcp.transport import StdioTransport, StreamableHTTPTransportfrom openjarvis.tools.mcp_adapter import MCPToolProvider- # Keep clients alive so transports persist for tool calls at runtime- mcp_clients: list = getattr(app_state, "_mcp_clients", [])-try:server_list = _json.loads(app_config.tools.mcp.servers)except (_json.JSONDecodeError, TypeError) as exc:@@ -704,6 +695,7 @@ def _get_mcp_tools(app_state: Any) -> Tuple[List[Dict[str, Any]], Dict[str, Any]command = cfg.get("command", "")args = cfg.get("args", [])+ client = Nonetry:if url:transport = StreamableHTTPTransport(url=url, token=token)@@ -717,8 +709,11 @@ def _get_mcp_tools(app_state: Any) -> Tuple[List[Dict[str, Any]], Dict[str, Any]continueclient = MCPClient(transport)+ if not _register_mcp_client(app_state, client):+ client.close()+ client = None+ breakclient.initialize()- mcp_clients.append(client)provider = MCPToolProvider(client)discovered = provider.discover()@@ -731,8 +726,16 @@ def _get_mcp_tools(app_state: Any) -> Tuple[List[Dict[str, Any]], Dict[str, Any]if exclude_tools:discovered = [t for t in discovered if t.spec.name not in exclude_tools]+ staged: list[tuple[Any, Any]] = []+ staged_names = set(adapters_by_name)for adapter in discovered:spec = adapter.spec+ if spec.name in staged_names:+ continue+ staged.append((adapter, spec))+ staged_names.add(spec.name)++ for adapter, spec in staged:openai_tools.append({"type": "function",@@ -745,22 +748,37 @@ def _get_mcp_tools(app_state: Any) -> Tuple[List[Dict[str, Any]], Dict[str, Any])adapters_by_name[spec.name] = adapter+ if not staged:+ client.close()+ _unregister_mcp_client(app_state, client)+ client = None+logger.info("Discovered %d MCP tools from server '%s'",- len(discovered),+ len(staged),name,)except Exception as exc:+ if client is not None:+ try:+ client.close()+ except Exception:+ logger.debug("Failed to close unusable MCP client", exc_info=True)+ else:+ _unregister_mcp_client(app_state, client)logger.warning("Failed to discover MCP tools from '%s': %s",name,exc,)- app_state._mcp_clients = mcp_clientsif openai_tools:- app_state._mcp_tools_cache = (openai_tools, adapters_by_name)- return openai_tools, adapters_by_name+ clients_lock = _mcp_state_lock(app_state, "_mcp_clients_lock")+ with clients_lock:+ if not getattr(app_state, "_managed_runtime_stopping", False):+ app_state._mcp_tools_cache = (openai_tools, adapters_by_name)+ return openai_tools, adapters_by_name+ return [], {}def _sse_chunk(chunk_id: str, model: str, content: str) -> str:@@ -824,6 +842,8 @@ async def _stream_managed_agent(import jsonimport uuid+ from starlette.background import BackgroundTask+from openjarvis.core.types import Message, Roleagent_id = agent_record["id"]@@ -861,16 +881,36 @@ async def _stream_managed_agent(Message(role=Role.SYSTEM, content=final_system_prompt.strip()))- # Resolve agent type and class for DeepResearch tool wiring+ # Resolve one live toolkit for every managed-agent path. The same+ # instances are advertised to the model and used for execution below.agent_type = agent_record.get("agent_type", "")- if agent_type == "deep_research":- dr_tools = _build_deep_research_tools(- engine=engine,- model=model,- )- # Store on app_state so streaming loop can access them- if app_state is not None and dr_tools:- app_state._dr_tools = dr_tools+ mcp_adapters: Dict[str, Any] = {}+ mcp_clients: list[Any] = []+ if app_state is not None and config.get("mcp_tools", True) is not False:+ try:+ _, mcp_adapters = _get_mcp_tools(app_state)+ mcp_clients = list(getattr(app_state, "_mcp_clients", []))+ except Exception as exc:+ logger.warning(+ "Failed to get MCP tools for managed agent: %s",+ exc,+ exc_info=True,+ )++ memory_backend = _get_or_create_memory_backend(app_state, app_config)+ channel_backend = getattr(app_state, "channel_backend", None) or getattr(+ app_state, "channel_bridge", None+ )+ resolved_toolkit = resolve_agent_tools(+ agent_record,+ engine=engine,+ model=model,+ memory_backend=memory_backend,+ channel_backend=channel_backend,+ mcp_tools=mcp_adapters.values(),+ mcp_clients=mcp_clients,+ knowledge_db_path=getattr(app_state, "knowledge_db_path", None),+ )# Load prior conversation context (DESC order, reverse for chronological).# Replaying recorded tool_calls (assistant tool-use + tool results) keeps@@ -887,15 +927,14 @@ async def _stream_managed_agent(chunk_id = f"chatcmpl-{uuid.uuid4().hex[:12]}"# For deep_research agents: run the full agent loop, not raw streaming- if agent_type == "deep_research" and app_state is not None:- dr_tools = getattr(app_state, "_dr_tools", None)+ if agent_type == "deep_research":+ dr_tools = resolved_toolkit.instancesif dr_tools:async def generate_deep_research():"""Run DeepResearchAgent in thread, stream progress + result."""import asyncioimport queue- import threadingimport time as _dr_timefrom openjarvis.agents.deep_research import DeepResearchAgent@@ -927,6 +966,8 @@ async def _stream_managed_agent(interactive=True,confirm_callback=lambda _prompt: True,)+ if resolved_toolkit.mcp_clients:+ dr_agent._mcp_clients = resolved_toolkit.mcp_clients# Wrap the executor to capture tool callsoriginal_execute = dr_agent._executor.execute@@ -997,6 +1038,8 @@ async def _stream_managed_agent(agent_metadata = result.metadata or {}except Exception as exc:content = f"Error: {exc}"+ finally:+ resolved_toolkit.close()elapsed = _dr_time.time() - _dr_start@@ -1028,8 +1071,22 @@ async def _stream_managed_agent(})- thread = threading.Thread(target=_run_agent, daemon=True)- thread.start()+ try:+ _start_managed_worker(+ app_state,+ _run_agent,+ name=f"managed-agent-deep-research-{agent_id}",+ )+ except Exception as exc:+ resolved_toolkit.close()+ progress_q.put(+ {+ "type": "error",+ "content": f"Error: {exc}",+ "metadata": {},+ "elapsed": _dr_time.time() - _dr_start,+ }+ )# Collect tool calls from deep-research so we can persist them# alongside the final response (and the UI can re-render them@@ -1163,35 +1220,26 @@ async def _stream_managed_agent(},)- # Build extra kwargs for stream_full (e.g. tools from config).- # Template stores tool names as strings; convert to OpenAI function specs- # so the engine can actually bind them to the model.+ # The canonical resolver exposes the same live instances as OpenAI specs+ # for engines that run the generic streaming loop.stream_kwargs: Dict[str, Any] = {}- resolved_tools = _resolve_tool_specs(config.get("tools"))- if resolved_tools:- stream_kwargs["tools"] = resolved_tools+ if resolved_toolkit.openai_specs:+ stream_kwargs["tools"] = resolved_toolkit.openai_specs++ from openjarvis.tools._stubs import ToolExecutor++ resolved_by_name = resolved_toolkit.by_name+ stream_tool_executor = ToolExecutor(+ tools=resolved_toolkit.instances,+ bus=bus,+ interactive=True,+ confirm_callback=lambda _prompt: True,+ )# Forward any per-agent sampler params (repetition_penalty, top_p, …) so# locally-hosted models can be tuned per agent (#386).stream_kwargs.update(_sampler_kwargs(config))- # Discover MCP tools and merge into stream_kwargs- mcp_adapters: Dict[str, Any] = {}- if app_state is not None:- try:- mcp_openai_tools, mcp_adapters = _get_mcp_tools(app_state)- if mcp_openai_tools:- existing_tools = stream_kwargs.get("tools", [])- stream_kwargs["tools"] = existing_tools + mcp_openai_tools- logger.info(- "Added %d MCP tools to streaming request",- len(mcp_openai_tools),- )- except Exception as exc:- logger.warning(- "Failed to get MCP tools for streaming: %s", exc, exc_info=True- )-# Shared state between the generator and the BackgroundTask that# runs after the SSE response completes (or the client disconnects# mid-stream). Starlette guarantees the BackgroundTask runs in both@@ -1234,6 +1282,12 @@ async def _stream_managed_agent(except Exception as _qc_exc:logger.warning("Log query_complete failed: %s", _qc_exc)+ def _finalize_stream() -> None:+ try:+ _persist_final()+ finally:+ resolved_toolkit.close()+async def generate():"""Async generator yielding SSE-formatted chunks with real token streaming."""@@ -1369,66 +1423,21 @@ async def _stream_managed_agent(tool_start_ms = _time.monotonic() * 1000try:- # Try MCP adapter first (external tools)- mcp_adapter = mcp_adapters.get(tool_name)- if mcp_adapter is not None:- try:- parsed_args = json.loads(tool_args) if tool_args else {}- except (json.JSONDecodeError, TypeError):- parsed_args = {}- result = mcp_adapter.execute(**parsed_args)+ if tool_name in resolved_by_name:+ result = stream_tool_executor.execute(+ MsgToolCall(+ id=tc["id"],+ name=tool_name,+ arguments=tool_args,+ )+ )tool_result_content = result.content+ tool_succeeded = bool(result.success)else:- # Try to use ToolExecutor if tools are configured- from openjarvis.core.registry import ToolRegistry- from openjarvis.tools._stubs import (- ToolCall as StubToolCall,- )- from openjarvis.tools._stubs import (- ToolExecutor,+ logger.warning(+ "Tool '%s' was not included in the resolved toolkit",+ tool_name,)-- tool_cls = ToolRegistry.get(tool_name)- if tool_cls is not None:- # Inject backend / channel / engine the same- # way cli/ask.py does, else memory_* / channel_*- # / llm tools fail with "No backend configured"- # on every call (#395).- tool_instance = _instantiate_managed_tool(- tool_cls,- tool_name,- engine=engine,- model=model,- app_state=app_state,- )- # Tools the user explicitly added to this- # agent's toolkit are considered pre-approved —- # selecting them in the wizard is the- # confirmation. Without this, tools that have- # `requires_confirmation=True` (shell_exec,- # apply_patch) would fail with "requires- # confirmation but no callback available" on- # every call.- executor = ToolExecutor(- tools=[tool_instance],- bus=bus,- interactive=True,- confirm_callback=lambda _prompt: True,- )- result = executor.execute(- StubToolCall(- id=tc["id"],- name=tool_name,- arguments=tool_args,- ),- )- tool_result_content = result.content- else:- logger.warning(- "Tool '%s' not found in registry or MCP adapters",- tool_name,- )- tool_succeeded = Trueexcept Exception as tool_exc:logger.error("Tool execution error for %s: %s",@@ -1516,13 +1525,11 @@ async def _stream_managed_agent(yield f"data: {json.dumps(final_data)}\n\n"yield "data: [DONE]\n\n"- from starlette.background import BackgroundTask-return StreamingResponse(generate(),media_type="text/event-stream",headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},- background=BackgroundTask(_persist_final),+ background=BackgroundTask(_finalize_stream),)@@ -1605,8 +1612,6 @@ def create_agent_manager_router(@agents_router.post("/{agent_id}/run")async def run_agent(agent_id: str, request: Request):- import threading-agent = manager.get_agent(agent_id)if not agent:raise HTTPException(status_code=404, detail="Agent not found")@@ -1644,6 +1649,7 @@ def create_agent_manager_router(server_engine,server_model,server_config,+ request.app.state,)executor.set_system(system)# The route handler above already called start_tick() to@@ -1668,7 +1674,18 @@ def create_agent_manager_router(f"ERROR: {exc}",)- threading.Thread(target=_run_tick, daemon=True).start()+ try:+ _start_managed_worker(+ request.app.state,+ _run_tick,+ name=f"managed-agent-run-{agent_id}",+ )+ except RuntimeError as exc:+ try:+ manager.end_tick(agent_id)+ except Exception:+ pass+ raise HTTPException(status_code=503, detail=str(exc))return {"status": "running", "agent_id": agent_id}# ── Recover ──────────────────────────────────────────────@@ -1753,10 +1770,6 @@ def create_agent_manager_router(engine = getattr(request.app.state, "engine", None)if engine:- from openjarvis.server.agent_manager_routes import (- _build_deep_research_tools,- )-tools = _build_deep_research_tools(engine=engine, model="")if tools:from openjarvis.agents.deep_research import (@@ -1825,11 +1838,7 @@ def create_agent_manager_router(engine = getattr(request.app.state, "engine", None)dr_agent = Noneif engine:- from openjarvis.server.agent_manager_routes import (- _build_deep_research_tools as _bdr,- )-- tools = _bdr(engine=engine, model="")+ tools = _build_deep_research_tools(engine=engine, model="")if tools:from openjarvis.agents.deep_research import (DeepResearchAgent,@@ -1971,7 +1980,6 @@ def create_agent_manager_router(# Non-streaming immediate: trigger a background tick so the# agent processes the message, then return the stored msg.# Re-use the server's existing system (correct model/engine).- import threadingimport time as _timefrom openjarvis.agents.executor import AgentExecutor@@ -1999,6 +2007,7 @@ def create_agent_manager_router(_srv_engine,_srv_model,_srv_config,+ request.app.state,)executor.set_system(system)logger.info(@@ -2030,10 +2039,14 @@ def create_agent_manager_router(f"ERROR: {exc}",)- threading.Thread(- target=_immediate_tick,- daemon=True,- ).start()+ try:+ _start_managed_worker(+ request.app.state,+ _immediate_tick,+ name=f"managed-agent-immediate-{agent_id}",+ )+ except RuntimeError as exc:+ raise HTTPException(status_code=503, detail=str(exc))return msg# --- Streaming mode: run agent and return SSE response ---diff --git a/src/openjarvis/server/app.py b/src/openjarvis/server/app.pyindex 35d42844..55c2dbd5 100644--- a/src/openjarvis/server/app.py+++ b/src/openjarvis/server/app.py@@ -4,6 +4,7 @@ from __future__ import annotationsimport loggingimport pathlib+import threadingimport timefrom fastapi import FastAPI@@ -21,6 +22,8 @@ from openjarvis.server.routes import routerfrom openjarvis.server.upload_router import router as upload_routerlogger = logging.getLogger(__name__)+_MANAGED_SHUTDOWN_GRACE_SECONDS = 0.25+_MANAGED_SHUTDOWN_DRAIN_SECONDS = 10.0def _restore_sendblue_bindings(app: FastAPI) -> None:@@ -151,10 +154,13 @@ def create_app(channel_bridge=None,config=None,memory_backend=None,+ own_memory_backend: bool = False,memory_service=None,speech_backend=None,agent_manager=None,agent_scheduler=None,+ mcp_tools=None,+ mcp_clients=None,api_key: str = "",webhook_config: dict | None = None,cors_origins: list[str] | None = None,@@ -221,16 +227,129 @@ def create_app()app.state.channel_bridge = channel_bridgeapp.state.config = config+ app.state._memory_backend_lock = threading.Lock()app.state.memory_backend = memory_backend+ app.state._owns_memory_backend = bool(own_memory_backend)app.state.memory_service = memory_serviceapp.state.speech_backend = speech_backendapp.state.agent_manager = agent_managerapp.state.agent_scheduler = agent_scheduler+ app.state.mcp_tools = list(mcp_tools or [])+ app.state._mcp_discovery_lock = threading.Lock()+ app.state._mcp_clients_lock = threading.Lock()+ app.state._mcp_clients = list(mcp_clients or [])+ app.state._managed_worker_lock = threading.Lock()+ app.state._managed_workers: set[threading.Thread] = set()+ app.state._managed_runtime_stopping = Falseapp.state.session_start = time.time()# Exposed so WebSocket handlers can authenticate the handshake (the HTTP# AuthMiddleware never sees WS upgrade requests). Empty = auth disabled.app.state.api_key = api_key+ @app.on_event("shutdown")+ async def _shutdown_managed_runtime() -> None:+ # Quiesce every producer before touching the shared MCP pool. Route+ # workers are registered under this lock, so none can slip in after+ # the snapshot. The scheduler has a two-phase stop because closing an+ # MCP transport may be what releases an in-flight tick.+ with app.state._managed_worker_lock:+ app.state._managed_runtime_stopping = True+ managed_workers = list(app.state._managed_workers)++ # Stop external listener threads before draining ticks or closing the+ # shared MCP pool. Channel callbacks are wired to that same pool by+ # ``serve`` and otherwise could race teardown or survive app restart.+ channel_bridge = getattr(app.state, "channel_bridge", None)+ disconnect_channels = getattr(channel_bridge, "disconnect", None)+ if callable(disconnect_channels):+ try:+ disconnect_channels()+ except Exception:+ logger.debug("Channel bridge shutdown failed", exc_info=True)++ def _join_workers(timeout: float) -> None:+ deadline = time.monotonic() + timeout+ for thread in managed_workers:+ remaining = deadline - time.monotonic()+ if remaining <= 0:+ break+ thread.join(timeout=remaining)++ scheduler = getattr(app.state, "agent_scheduler", None)+ scheduler_wait = None+ scheduler_drained = True+ if scheduler is not None:+ try:+ request_stop = getattr(scheduler, "request_stop", None)+ wait_stopped = getattr(scheduler, "wait_stopped", None)+ if callable(request_stop) and callable(wait_stopped):+ request_stop()+ scheduler_wait = wait_stopped+ scheduler_drained = bool(+ wait_stopped(timeout=_MANAGED_SHUTDOWN_GRACE_SECONDS)+ )+ else:+ scheduler.stop()+ scheduler_drained = not bool(+ getattr(scheduler, "is_running", False)+ )+ except Exception:+ scheduler_drained = False+ logger.debug("Agent scheduler shutdown failed", exc_info=True)++ # Give normal work a brief chance to finish before cancellation.+ _join_workers(timeout=_MANAGED_SHUTDOWN_GRACE_SECONDS)+ with app.state._mcp_clients_lock:+ mcp_clients_to_close = list(app.state._mcp_clients)+ for client in mcp_clients_to_close:+ try:+ client.close()+ except Exception:+ logger.debug("MCP client shutdown failed", exc_info=True)++ # Transport closure interrupts blocked MCP reads. Drain the workers a+ # second time so shutdown does not return while they still own runtime+ # state. Any stragglers can no longer issue transport requests because+ # MCPClient marks itself closed before closing its transport.+ if scheduler_wait is not None:+ try:+ scheduler_drained = bool(+ scheduler_wait(timeout=_MANAGED_SHUTDOWN_DRAIN_SECONDS)+ )+ except Exception:+ scheduler_drained = False+ logger.debug("Agent scheduler drain failed", exc_info=True)+ _join_workers(timeout=_MANAGED_SHUTDOWN_DRAIN_SECONDS)+ alive = [thread.name for thread in managed_workers if thread.is_alive()]+ if alive:+ logger.warning("Managed workers did not stop during shutdown: %s", alive)++ # A backend created by ``serve`` or lazily by a managed route belongs+ # to this app process. Close it only after every tracked consumer has+ # been drained; injected/borrowed backends remain the caller's concern.+ owned_memory_backend = None+ runtime_drained = scheduler_drained and not alive+ if runtime_drained:+ with app.state._memory_backend_lock:+ if app.state._owns_memory_backend:+ owned_memory_backend = app.state.memory_backend+ app.state.memory_backend = None+ app.state._owns_memory_backend = False+ else:+ # A live worker may itself hold _memory_backend_lock while opening+ # the backend. Respect the bounded shutdown deadline: do not wait+ # on that lock or mutate ownership until every consumer is gone.+ logger.warning(+ "Skipping memory backend cleanup because managed runtime "+ "consumers did not stop"+ )+ close_memory = getattr(owned_memory_backend, "close", None)+ if callable(close_memory):+ try:+ close_memory()+ except Exception:+ logger.debug("Memory backend shutdown failed", exc_info=True)+# Wire up trace store if traces are enabled.## We deliberately do NOT subscribe the trace store to the bus. The chatdiff --git a/src/openjarvis/system/builder.py b/src/openjarvis/system/builder.pyindex 743bb7b1..e0fde9c6 100644--- a/src/openjarvis/system/builder.py+++ b/src/openjarvis/system/builder.py@@ -48,6 +48,7 @@ class SystemBuilder:self._sessions: Optional[bool] = Noneself._speech: Optional[bool] = Noneself._mcp_clients: List = []+ self._mcp_tools: List[BaseTool] = []def engine(self, key: str) -> SystemBuilder:self._engine_key = key@@ -113,6 +114,33 @@ class SystemBuilder:def build(self) -> JarvisSystem:"""Construct a fully wired JarvisSystem."""+ # Discovery state belongs to one build only. Once a system is+ # returned, that system owns the clients and adapters captured below;+ # retaining them here would make a reused builder hand closed clients+ # from an earlier system to the next one.+ self._clear_mcp_discovery_state(close_clients=True)+ try:+ system = self._build()+ except BaseException:+ # No system took ownership, so release any clients opened before+ # the build failed.+ self._clear_mcp_discovery_state(close_clients=True)+ raise+ self._clear_mcp_discovery_state(close_clients=False)+ return system++ def _clear_mcp_discovery_state(self, *, close_clients: bool) -> None:+ if close_clients:+ for client in getattr(self, "_mcp_clients", []):+ try:+ client.close()+ except Exception:+ logger.debug("Error closing unowned MCP client", exc_info=True)+ self._mcp_clients = []+ self._mcp_tools = []++ def _build(self) -> JarvisSystem:+ """Build one system using fresh, build-local MCP discovery state."""config = self._configbus = self._bus or get_event_bus()@@ -291,6 +319,7 @@ class SystemBuilder:model=model,agent_name=agent_name,tools=tool_list,+ mcp_tools=list(self._mcp_tools),tool_executor=tool_executor,memory_backend=memory_backend,channel_backend=channel_backend,@@ -440,7 +469,7 @@ class SystemBuilder:else:tools = []- if config.tools.mcp.servers:+ if config.tools.mcp.enabled and config.tools.mcp.servers:try:import json@@ -449,6 +478,7 @@ class SystemBuilder:for server_cfg in server_list:try:external_tools = self._discover_external_mcp(server_cfg)+ self._mcp_tools.extend(external_tools)if tool_names:external_tools = [tdiff --git a/src/openjarvis/system/core.py b/src/openjarvis/system/core.pyindex 95f48179..e0d803f1 100644--- a/src/openjarvis/system/core.py+++ b/src/openjarvis/system/core.py@@ -86,6 +86,9 @@ class JarvisSystem:skill_manager: Optional[SkillManager] = None_learning_orchestrator: Optional[LearningOrchestrator] = None_mcp_clients: List[MCPClient] = field(default_factory=list)+ # Keep newly added fields after every pre-existing positional field so+ # older positional JarvisSystem(...) calls retain their original meaning.+ mcp_tools: List[BaseTool] = field(default_factory=list)@propertydef security(self) -> SecurityContext:diff --git a/tests/agents/test_executor_tool_persistence.py b/tests/agents/test_executor_tool_persistence.pynew file mode 100644index 00000000..18c325c8--- /dev/null+++ b/tests/agents/test_executor_tool_persistence.py@@ -0,0 +1,127 @@+"""Regression tests for managed-agent tool-call persistence."""++from __future__ import annotations++import json++import pytest++from openjarvis.agents._stubs import AgentResult+from openjarvis.agents.executor import AgentExecutor, _tool_calls_for_storage+from openjarvis.agents.manager import AgentManager+from openjarvis.core.events import EventBus+from openjarvis.core.types import ToolResult+++def test_tool_results_are_serialized_for_managed_messages() -> None:+ result = AgentResult(+ content="Finished",+ tool_results=[+ ToolResult(+ tool_name="knowledge_search",+ content="Found the requested note",+ success=True,+ latency_seconds=0.42,+ metadata={+ "arguments": {+ "query": "financial independence",+ "limit": 3,+ }+ },+ ),+ ToolResult(+ tool_name="shell_exec",+ content="Permission denied",+ success=False,+ latency_seconds=1.25,+ metadata={"arguments": '{"command":"whoami"}'},+ ),+ ],+ )++ calls = _tool_calls_for_storage(result)++ assert calls is not None+ assert len(calls) == 2++ knowledge_call = calls[0]+ assert knowledge_call["tool"] == "knowledge_search"+ assert isinstance(knowledge_call["arguments"], str)+ assert json.loads(knowledge_call["arguments"]) == {+ "query": "financial independence",+ "limit": 3,+ }+ assert knowledge_call["result"] == "Found the requested note"+ assert knowledge_call["success"] is True+ assert knowledge_call["latency"] == pytest.approx(420.0)++ failed_call = calls[1]+ assert failed_call["arguments"] == '{"command":"whoami"}'+ assert failed_call["result"] == "Permission denied"+ assert failed_call["success"] is False+ assert failed_call["latency"] == pytest.approx(1250.0)+++def test_no_tool_results_serialize_as_none() -> None:+ assert _tool_calls_for_storage(AgentResult(content="Plain response")) is None+++def test_finalize_tick_persists_tool_calls_round_trip(tmp_path) -> None:+ manager = AgentManager(str(tmp_path / "agents.db"))+ try:+ agent = manager.create_agent("researcher")+ manager.start_tick(agent["id"])+ result = AgentResult(+ content="Answer grounded in the knowledge base",+ tool_results=[+ ToolResult(+ tool_name="knowledge_search",+ content="Matching source text",+ success=True,+ latency_seconds=0.007,+ metadata={"arguments": {"query": "grounded answer"}},+ )+ ],+ )++ executor = AgentExecutor(manager, EventBus())+ executor._finalize_tick(+ agent["id"],+ result,+ error=None,+ duration=0.01,+ )++ messages = manager.list_messages(agent["id"])+ assert len(messages) == 1+ stored = messages[0]+ assert stored["content"] == result.content+ assert stored["direction"] == "agent_to_user"+ assert stored["tool_calls"] == _tool_calls_for_storage(result)+ assert isinstance(stored["tool_calls"][0]["arguments"], str)+ assert json.loads(stored["tool_calls"][0]["arguments"]) == {+ "query": "grounded answer"+ }+ assert stored["tool_calls"][0]["latency"] == pytest.approx(7.0)+ finally:+ manager.close()+++def test_finalize_tick_without_tools_stores_null_tool_calls(tmp_path) -> None:+ manager = AgentManager(str(tmp_path / "agents.db"))+ try:+ agent = manager.create_agent("plain-agent")+ manager.start_tick(agent["id"])++ executor = AgentExecutor(manager, EventBus())+ executor._finalize_tick(+ agent["id"],+ AgentResult(content="No tools needed"),+ error=None,+ duration=0.01,+ )++ stored = manager.list_messages(agent["id"])[0]+ assert stored["tool_calls"] is None+ finally:+ manager.close()diff --git a/tests/agents/test_executor_tools.py b/tests/agents/test_executor_tools.pyindex 70e26132..ad94ddcb 100644--- a/tests/agents/test_executor_tools.py+++ b/tests/agents/test_executor_tools.py@@ -2,13 +2,91 @@from __future__ import annotations+import gc+import sqlite3+from types import SimpleNamespace+from unittest.mock import MagicMock++import pytest++from openjarvis.agents._stubs import AgentResultfrom openjarvis.agents.executor import AgentExecutorfrom openjarvis.agents.manager import AgentManager+from openjarvis.agents.tool_resolver import ResolvedAgentTools+from openjarvis.connectors.store import KnowledgeStore+from openjarvis.core.config import MemoryFilesConfig, SystemPromptConfigfrom openjarvis.core.events import EventBus+from openjarvis.core.registry import AgentRegistry, ToolRegistry+from openjarvis.core.types import Role, ToolResult+from openjarvis.tools._stubs import BaseTool, ToolSpecfrom tests.agents.fake_engine import FakeEnginefrom tests.agents.scenario_harness import FakeSystem+class _CapturingToolAgent:+ """Minimal agent that exposes the toolkit received by AgentExecutor."""++ accepts_tools = True+ captured_tools = []+ captured_search_result = None++ def __init__(self, engine, model, *, tools=None, **kwargs):+ self.engine = engine+ self.model = model+ type(self).captured_tools = list(tools or [])++ def run(self, input_text, context=None):+ tools_by_name = {tool.spec.name: tool for tool in self.captured_tools}+ search = tools_by_name.get("knowledge_search")+ if search is not None:+ type(self).captured_search_result = search.execute(+ query="EXECUTOR_RESOLVER_SENTINEL"+ )+ return AgentResult(content="captured")+++class _NonToolAgent:+ """Agent class whose run method must not swallow a configured toolkit."""++ accepts_tools = False+ supports_managed_tool_fallback = True+ runs = 0++ def __init__(self, engine, model, **kwargs):+ pass++ def run(self, input_text, context=None):+ type(self).runs += 1+ raise AssertionError("non-tool agent should use the managed tool loop")+++class _SpecializedNonToolAgent:+ """Non-tool agent that must retain its specialized execution path."""++ accepts_tools = False+ runs = 0++ def __init__(self, engine, model, **kwargs):+ pass++ def run(self, input_text, context=None):+ type(self).runs += 1+ return AgentResult(content="specialized response")+++class _ExecutorProbeTool(BaseTool):+ tool_id = "executor_probe"+ calls = 0++ @property+ def spec(self) -> ToolSpec:+ return ToolSpec(name=self.tool_id, description="Executor parity probe")++ def execute(self, **params) -> ToolResult:+ type(self).calls += 1+ return ToolResult(tool_name=self.tool_id, content="probe-result")++def _register_agent():"""Re-register MonitorOperativeAgent (cleared by autouse fixture)."""from openjarvis.agents.monitor_operative import MonitorOperativeAgent@@ -102,3 +180,396 @@ def test_executor_handles_string_tools(tmp_path):result_agent = mgr.get_agent(agent["id"])assert result_agent["status"] == "idle"mgr.close()+++def test_executor_uses_tool_loop_for_non_tool_agent_with_configured_tools(tmp_path):+ """Immediate/scheduled ticks match SSE instead of discarding tools."""++ AgentRegistry.register_value("non_tool_probe", _NonToolAgent)+ ToolRegistry.register_value(_ExecutorProbeTool.tool_id, _ExecutorProbeTool)+ _NonToolAgent.runs = 0+ _ExecutorProbeTool.calls = 0++ engine = FakeEngine(+ [+ {+ "tool_calls": [+ {+ "id": "call-executor-probe",+ "name": _ExecutorProbeTool.tool_id,+ "arguments": "{}",+ }+ ]+ },+ {"content": "tool-backed final response"},+ ]+ )+ system = FakeSystem(engine=engine)+ system.config = SimpleNamespace(+ agent=SimpleNamespace(default_system_prompt="GLOBAL_DEFAULT"),+ memory_files=MemoryFilesConfig(persona_name="none"),+ system_prompt=SystemPromptConfig(),+ )+ manager = AgentManager(db_path=str(tmp_path / "agents.db"))+ agent = manager.create_agent(+ "non-tool with tools",+ agent_type="non_tool_probe",+ config={+ "model": "test-model",+ "tools": [_ExecutorProbeTool.tool_id],+ "instruction": "Use the probe.",+ "system_prompt": "NON_TOOL_SYSTEM_SENTINEL",+ },+ )++ try:+ AgentExecutor(manager, EventBus(), system=system).execute_tick(agent["id"])++ assert _NonToolAgent.runs == 0+ assert _ExecutorProbeTool.calls == 1+ assert engine.call_count == 2+ assert any(+ message.role is Role.SYSTEM+ and message.content == "NON_TOOL_SYSTEM_SENTINEL"+ for message in engine.last_messages or []+ )+ refreshed = manager.get_agent(agent["id"])+ assert refreshed["status"] == "idle"+ assert refreshed["total_runs"] == 1+ responses = [+ message+ for message in manager.list_messages(agent["id"])+ if message["direction"] == "agent_to_user"+ ]+ assert responses[-1]["content"] == "tool-backed final response"+ assert responses[-1]["tool_calls"][0]["tool"] == "executor_probe"+ finally:+ manager.close()+++def test_simple_agent_uses_global_mcp_tools_without_native_tool_config(tmp_path):+ """Fallback-compatible simple agents preserve SSE/global-MCP parity."""++ from openjarvis.agents.simple import SimpleAgent++ AgentRegistry.register_value("simple", SimpleAgent)+ _ExecutorProbeTool.calls = 0+ provider = MagicMock(return_value=([_ExecutorProbeTool()], []))+ engine = FakeEngine(+ [+ {+ "tool_calls": [+ {+ "id": "call-global-mcp-probe",+ "name": _ExecutorProbeTool.tool_id,+ "arguments": "{}",+ }+ ]+ },+ {"content": "global MCP response"},+ ]+ )+ system = SimpleNamespace(+ engine=engine,+ model="test-model",+ config=None,+ memory_backend=None,+ channel_backend=None,+ session_store=None,+ knowledge_db_path=None,+ get_managed_agent_mcp_tools=provider,+ )+ manager = AgentManager(db_path=str(tmp_path / "agents.db"))+ agent = manager.create_agent(+ "simple global MCP",+ agent_type="simple",+ config={"model": "test-model", "instruction": "Use MCP."},+ )++ try:+ AgentExecutor(manager, EventBus(), system=system).execute_tick(agent["id"])++ provider.assert_called_once_with()+ assert _ExecutorProbeTool.calls == 1+ assert engine.call_count == 2+ responses = [+ message+ for message in manager.list_messages(agent["id"])+ if message["direction"] == "agent_to_user"+ ]+ assert responses[-1]["content"] == "global MCP response"+ finally:+ manager.close()+++def test_simple_agent_without_tools_keeps_its_custom_system_prompt(tmp_path):+ """Signature filtering must not discard prompt-builder state on retry."""++ from openjarvis.agents.simple import SimpleAgent++ AgentRegistry.register_value("simple", SimpleAgent)+ engine = FakeEngine([{"content": "custom prompt response"}])+ system = FakeSystem(engine=engine)+ system.config = SimpleNamespace(+ agent=SimpleNamespace(default_system_prompt="GLOBAL_DEFAULT"),+ memory_files=MemoryFilesConfig(persona_name="none"),+ system_prompt=SystemPromptConfig(),+ )+ manager = AgentManager(db_path=str(tmp_path / "agents.db"))+ agent = manager.create_agent(+ "simple custom prompt",+ agent_type="simple",+ config={+ "model": "test-model",+ "instruction": "Answer directly.",+ "system_prompt": "SIMPLE_CUSTOM_SYSTEM_SENTINEL",+ "mcp_tools": False,+ },+ )++ try:+ AgentExecutor(manager, EventBus(), system=system).execute_tick(agent["id"])++ assert engine.call_count == 1+ assert any(+ message.role is Role.SYSTEM+ and message.content == "SIMPLE_CUSTOM_SYSTEM_SENTINEL"+ for message in engine.last_messages or []+ )+ finally:+ manager.close()+++def test_specialized_non_tool_agent_is_not_replaced_by_generic_tool_loop(tmp_path):+ """Configured/global tools never replace a non-opted-in agent class."""++ AgentRegistry.register_value("specialized_non_tool", _SpecializedNonToolAgent)+ ToolRegistry.register_value(_ExecutorProbeTool.tool_id, _ExecutorProbeTool)+ _SpecializedNonToolAgent.runs = 0+ _ExecutorProbeTool.calls = 0+ provider = MagicMock(return_value=([_ExecutorProbeTool()], []))+ system = SimpleNamespace(+ engine=FakeEngine([{"content": "unused"}]),+ model="test-model",+ config=None,+ memory_backend=None,+ channel_backend=None,+ session_store=None,+ knowledge_db_path=None,+ get_managed_agent_mcp_tools=provider,+ )+ manager = AgentManager(db_path=str(tmp_path / "agents.db"))+ agent = manager.create_agent(+ "specialized with configured tool",+ agent_type="specialized_non_tool",+ config={+ "model": "test-model",+ "instruction": "Keep the specialized path.",+ "tools": [_ExecutorProbeTool.tool_id],+ },+ )++ try:+ AgentExecutor(manager, EventBus(), system=system).execute_tick(agent["id"])++ provider.assert_not_called()+ assert _SpecializedNonToolAgent.runs == 1+ assert _ExecutorProbeTool.calls == 0+ responses = [+ message+ for message in manager.list_messages(agent["id"])+ if message["direction"] == "agent_to_user"+ ]+ assert responses[-1]["content"] == "specialized response"+ finally:+ manager.close()+++def test_executor_grants_deep_research_live_knowledge_tools(tmp_path):+ """Immediate ticks receive the same live Deep Research grant as SSE."""++ AgentRegistry.register_value("deep_research", _CapturingToolAgent)+ _CapturingToolAgent.captured_tools = []+ _CapturingToolAgent.captured_search_result = None++ knowledge_db_path = tmp_path / "knowledge.db"+ with KnowledgeStore(db_path=knowledge_db_path) as store:+ store.store(+ "The EXECUTOR_RESOLVER_SENTINEL decision was approved.",+ source="test",+ doc_type="note",+ )++ manager = AgentManager(db_path=str(tmp_path / "agents.db"))+ agent = manager.create_agent(+ "researcher",+ agent_type="deep_research",+ config={+ "model": "agent-selected-model",+ # These duplicate two agent-type grants and must not replace them.+ "tools": ["knowledge_search", "think"],+ "instruction": "Find the sentinel.",+ },+ )+ manager.send_message(agent["id"], "Search the knowledge base.", mode="immediate")++ system = SimpleNamespace(+ engine=FakeEngine([{"content": "unused"}]),+ model="system-model",+ memory_backend=None,+ channel_backend=None,+ tool_executor=None,+ _mcp_clients=[],+ knowledge_db_path=knowledge_db_path,+ config=None,+ session_store=None,+ )+ executor = AgentExecutor(manager=manager, event_bus=EventBus(), system=system)++ try:+ executor.execute_tick(agent["id"])++ tools_by_name = {+ tool.spec.name: tool for tool in _CapturingToolAgent.captured_tools+ }+ assert set(tools_by_name) == {+ "knowledge_search",+ "knowledge_sql",+ "scan_chunks",+ "think",+ }+ result = _CapturingToolAgent.captured_search_result+ assert result is not None+ assert result.success is True+ assert "EXECUTOR_RESOLVER_SENTINEL" in result.content+ assert tools_by_name["scan_chunks"]._model == "agent-selected-model"+ assert manager.get_agent(agent["id"])["status"] == "idle"+ with pytest.raises(sqlite3.ProgrammingError):+ tools_by_name["knowledge_sql"]._store._conn.execute("SELECT 1")+ finally:+ manager.close()+++def test_executor_mcp_opt_out_does_not_call_lazy_provider(tmp_path):+ """An opted-out tick must not trigger request-local MCP discovery."""++ AgentRegistry.register_value("capturing", _CapturingToolAgent)+ provider = MagicMock(side_effect=AssertionError("MCP discovery must stay lazy"))+ system = SimpleNamespace(+ engine=FakeEngine([{"content": "unused"}]),+ model="system-model",+ memory_backend=None,+ channel_backend=None,+ tool_executor=None,+ _mcp_clients=[],+ config=None,+ session_store=None,+ get_managed_agent_mcp_tools=provider,+ )+ manager = AgentManager(db_path=str(tmp_path / "agents.db"))+ agent = manager.create_agent(+ "no-mcp",+ agent_type="capturing",+ config={"model": "test-model", "mcp_tools": False},+ )++ try:+ AgentExecutor(manager, EventBus(), system=system).execute_tick(agent["id"])+ provider.assert_not_called()+ assert manager.get_agent(agent["id"])["status"] == "idle"+ finally:+ manager.close()+++def test_executor_preserves_custom_dict_tool_schema(tmp_path):+ """Executor-based agents see the same custom schema advertised by SSE."""++ from openjarvis.tools.think import ThinkTool++ AgentRegistry.register_value("capturing", _CapturingToolAgent)+ ToolRegistry.register_value("think", ThinkTool)+ _CapturingToolAgent.captured_tools = []+ custom_spec = {+ "type": "function",+ "function": {+ "name": "think",+ "description": "Agent-specific thinking schema",+ "parameters": {+ "type": "object",+ "properties": {"thought": {"type": "string"}},+ "required": ["thought"],+ },+ },+ }+ system = SimpleNamespace(+ engine=FakeEngine([{"content": "unused"}]),+ model="test-model",+ memory_backend=None,+ channel_backend=None,+ tool_executor=None,+ mcp_tools=[],+ _mcp_clients=[],+ config=None,+ session_store=None,+ )+ manager = AgentManager(db_path=str(tmp_path / "agents.db"))+ agent = manager.create_agent(+ "custom-schema",+ agent_type="capturing",+ config={"model": "test-model", "tools": [custom_spec]},+ )++ try:+ AgentExecutor(manager, EventBus(), system=system).execute_tick(agent["id"])+ assert len(_CapturingToolAgent.captured_tools) == 1+ configured_tool = _CapturingToolAgent.captured_tools[0]+ assert configured_tool.to_openai_function() == custom_spec+ assert configured_tool.spec.description == "Agent-specific thinking schema"+ assert configured_tool.execute(thought="same instance").success is True+ finally:+ manager.close()+++def test_executor_closes_resolver_resources_when_pre_run_setup_fails(+ tmp_path,+ monkeypatch,+):+ """The resolver finalizer covers failures before agent.run is reached."""++ AgentRegistry.register_value("capturing", _CapturingToolAgent)+ resource = MagicMock()++ def _resolve(*args, **kwargs):+ return ResolvedAgentTools(owned_resources=[resource])++ monkeypatch.setattr("openjarvis.agents.executor.resolve_agent_tools", _resolve)+ system = SimpleNamespace(+ engine=FakeEngine([{"content": "unused"}]),+ model="test-model",+ memory_backend=None,+ channel_backend=None,+ tool_executor=None,+ mcp_tools=[],+ _mcp_clients=[],+ config=None,+ session_store=None,+ )+ manager = AgentManager(db_path=str(tmp_path / "agents.db"))+ agent = manager.create_agent(+ "cleanup",+ agent_type="capturing",+ config={"model": "test-model"},+ )+ monkeypatch.setattr(+ manager,+ "get_pending_messages",+ MagicMock(side_effect=RuntimeError("pre-run setup failed")),+ )++ try:+ with pytest.raises(RuntimeError, match="pre-run setup failed"):+ AgentExecutor(manager, EventBus(), system=system)._invoke_agent(agent)+ gc.collect()+ resource.close.assert_called_once_with()+ finally:+ manager.close()diff --git a/tests/agents/test_scheduler.py b/tests/agents/test_scheduler.pyindex b4ac38ec..7a7b41da 100644--- a/tests/agents/test_scheduler.py+++ b/tests/agents/test_scheduler.py@@ -3,6 +3,7 @@from __future__ import annotationsimport tempfile+import threadingimport timefrom pathlib import Pathfrom unittest.mock import MagicMock@@ -117,6 +118,48 @@ class TestSchedulerBasic:assert executor.execute_tick.call_count >= 1executor.execute_tick.assert_called_with(agent["id"])+ def test_two_phase_stop_retains_and_drains_active_worker(self, manager):+ """Shutdown quiesces later ticks and can wait again after cancellation."""++ from openjarvis.agents.scheduler import AgentScheduler++ started = threading.Event()+ release = threading.Event()+ calls: list[str] = []++ class _BlockingExecutor:+ def execute_tick(self, agent_id):+ calls.append(agent_id)+ started.set()+ release.wait(timeout=2)++ scheduler = AgentScheduler(+ manager=manager,+ executor=_BlockingExecutor(),+ tick_interval=0.01,+ )+ agents = [+ manager.create_agent(+ name=f"test-{index}",+ agent_type="monitor_operative",+ config={"schedule_type": "interval", "schedule_value": 0},+ )+ for index in range(2)+ ]+ for agent in agents:+ scheduler.register_agent(agent["id"])++ scheduler.start()+ assert started.wait(timeout=1)+ scheduler.request_stop()+ assert scheduler.wait_stopped(timeout=0.01) is False+ assert scheduler._thread is not None++ release.set()+ assert scheduler.wait_stopped(timeout=1) is True+ assert scheduler._thread is None+ assert calls == [agents[0]["id"]]+def test_skips_paused_agents(self, manager):from openjarvis.agents.scheduler import AgentSchedulerdiff --git a/tests/agents/test_tool_resolver.py b/tests/agents/test_tool_resolver.pynew file mode 100644index 00000000..0d640400--- /dev/null+++ b/tests/agents/test_tool_resolver.py@@ -0,0 +1,284 @@+"""Focused tests for canonical managed-agent tool resolution (#688)."""++from __future__ import annotations++from collections import Counter++import pytest++from openjarvis.agents import tool_resolver+from openjarvis.connectors.store import KnowledgeStore+from openjarvis.core.registry import ToolRegistry+from openjarvis.core.types import ToolResult+from openjarvis.tools import description_loader+from openjarvis.tools._stubs import BaseTool, ToolSpec+++class _AlphaTool(BaseTool):+ tool_id = "alpha"++ @property+ def spec(self) -> ToolSpec:+ return ToolSpec(name="alpha", description="Alpha test tool")++ def execute(self, **params) -> ToolResult:+ return ToolResult(tool_name="alpha", content="alpha", success=True)+++class _BetaTool(BaseTool):+ tool_id = "beta"++ @property+ def spec(self) -> ToolSpec:+ return ToolSpec(name="beta", description="Beta test tool")++ def execute(self, **params) -> ToolResult:+ return ToolResult(tool_name="beta", content="beta", success=True)+++class _NativeSharedTool(BaseTool):+ tool_id = "shared"++ @property+ def spec(self) -> ToolSpec:+ return ToolSpec(name="shared", description="Native shared tool")++ def execute(self, **params) -> ToolResult:+ return ToolResult(tool_name="shared", content="native", success=True)+++class _MCPSharedTool(BaseTool):+ tool_id = "shared"++ @property+ def spec(self) -> ToolSpec:+ return ToolSpec(name="shared", description="MCP name collision")++ def execute(self, **params) -> ToolResult:+ return ToolResult(tool_name="shared", content="mcp", success=True)+++class _MCPOnlyTool(BaseTool):+ tool_id = "mcp_only"++ @property+ def spec(self) -> ToolSpec:+ return ToolSpec(name="mcp_only", description="MCP-only test tool")++ def execute(self, **params) -> ToolResult:+ return ToolResult(tool_name="mcp_only", content="mcp-only", success=True)++[email protected](autouse=True)+def _use_explicit_test_registrations(monkeypatch: pytest.MonkeyPatch) -> None:+ """Keep these unit tests independent of import-time registry population."""++ monkeypatch.setattr(tool_resolver, "ensure_registries_populated", lambda: None)+++def test_deep_research_grants_are_live_deduplicated_and_use_selected_model(+ tmp_path,+) -> None:+ """Agent-type grants must beat duplicate bare configured tools."""++ db_path = tmp_path / "knowledge.db"+ with KnowledgeStore(db_path=db_path) as store:+ store.store(+ "The RESOLVER_SENTINEL decision was approved.",+ source="test",+ doc_type="note",+ )++ engine = object()+ resolved = tool_resolver.resolve_agent_tools(+ {+ "agent_type": "deep_research",+ "config": {+ # Both names are already supplied by the agent-type grant.+ "tools": ["knowledge_search", "think", "think"],+ },+ },+ engine=engine,+ model="agent-selected-model",+ knowledge_db_path=db_path,+ )++ try:+ names = [tool.spec.name for tool in resolved.instances]+ assert set(names) == {+ "knowledge_search",+ "knowledge_sql",+ "scan_chunks",+ "think",+ }+ assert all(count == 1 for count in Counter(names).values())++ search = resolved.by_name["knowledge_search"]+ result = search.execute(query="RESOLVER_SENTINEL")+ assert result.success is True+ assert "RESOLVER_SENTINEL" in result.content++ scan = resolved.by_name["scan_chunks"]+ assert scan._engine is engine+ assert scan._model == "agent-selected-model"+ finally:+ # All three knowledge tools share this store connection.+ resolved.by_name["knowledge_sql"]._store.close()+++ "tool_config",+ [+ ["alpha", "beta", "alpha"],+ " alpha, beta, alpha ",+ ],+)+def test_configured_tools_normalize_lists_and_comma_separated_strings(+ tool_config,+) -> None:+ ToolRegistry.register_value("alpha", _AlphaTool)+ ToolRegistry.register_value("beta", _BetaTool)++ resolved = tool_resolver.resolve_agent_tools(+ {"agent_type": "simple", "config": {"tools": tool_config}},+ engine=object(),+ model="test-model",+ )++ assert [tool.spec.name for tool in resolved.instances] == ["alpha", "beta"]+ assert [spec["function"]["name"] for spec in resolved.openai_specs] == [+ "alpha",+ "beta",+ ]+++def test_registered_tool_advertisement_matches_to_openai_function(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """Runtime description overrides must reach canonical advertisements."""++ ToolRegistry.register_value("alpha", _AlphaTool)+ monkeypatch.setattr(+ description_loader,+ "get_tool_description_override",+ lambda name: "Runtime alpha description" if name == "alpha" else None,+ )++ resolved = tool_resolver.resolve_agent_tools(+ {"agent_type": "simple", "config": {"tools": ["alpha"]}},+ engine=object(),+ model="test-model",+ )++ tool = resolved.by_name["alpha"]+ assert resolved.openai_specs == [tool.to_openai_function()]+ assert (+ resolved.openai_specs[0]["function"]["description"]+ == "Runtime alpha description"+ )+++def test_explicit_config_schema_takes_priority_over_tool_advertisement(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ ToolRegistry.register_value("alpha", _AlphaTool)+ monkeypatch.setattr(+ description_loader,+ "get_tool_description_override",+ lambda name: "Runtime alpha description" if name == "alpha" else None,+ )+ custom_spec = {+ "type": "function",+ "function": {+ "name": "alpha",+ "description": "Agent-specific alpha description",+ "parameters": {+ "type": "object",+ "properties": {"query": {"type": "string"}},+ "required": ["query"],+ },+ },+ }++ resolved = tool_resolver.resolve_agent_tools(+ {"agent_type": "simple", "config": {"tools": [custom_spec]}},+ engine=object(),+ model="test-model",+ )++ assert resolved.openai_specs == [custom_spec]+ assert resolved.by_name["alpha"].to_openai_function() == custom_spec+++def test_invalid_tool_advertisement_falls_back_to_tool_spec() -> None:+ class _InvalidAdvertisementTool(_AlphaTool):+ def to_openai_function(self) -> dict[str, object]:+ raise RuntimeError("broken advertisement")++ ToolRegistry.register_value("alpha", _InvalidAdvertisementTool)++ resolved = tool_resolver.resolve_agent_tools(+ {"agent_type": "simple", "config": {"tools": ["alpha"]}},+ engine=object(),+ model="test-model",+ )++ assert resolved.openai_specs == [+ {+ "type": "function",+ "function": {+ "name": "alpha",+ "description": "Alpha test tool",+ "parameters": {},+ },+ }+ ]+++def test_mcp_tools_merge_after_native_tools_without_name_collisions() -> None:+ ToolRegistry.register_value("shared", _NativeSharedTool)+ mcp_shared = _MCPSharedTool()+ mcp_only = _MCPOnlyTool()+ client = object()++ resolved = tool_resolver.resolve_agent_tools(+ {+ "agent_type": "simple",+ "config": {"tools": ["shared", "shared"]},+ },+ engine=object(),+ model="test-model",+ mcp_tools=[mcp_shared, mcp_only, mcp_only],+ mcp_clients=[client],+ )++ assert [tool.spec.name for tool in resolved.instances] == ["shared", "mcp_only"]+ assert isinstance(resolved.by_name["shared"], _NativeSharedTool)+ assert resolved.by_name["mcp_only"] is mcp_only+ assert resolved.mcp_clients == [client]+ assert [spec["function"]["name"] for spec in resolved.openai_specs] == [+ "shared",+ "mcp_only",+ ]+++def test_mcp_tools_can_be_disabled_per_agent() -> None:+ ToolRegistry.register_value("shared", _NativeSharedTool)++ class _MustNotIterate:+ def __iter__(self):+ raise AssertionError("MCP tools must not be inspected after opt-out")++ resolved = tool_resolver.resolve_agent_tools(+ {+ "agent_type": "simple",+ "config": {"tools": ["shared"], "mcp_tools": False},+ },+ engine=object(),+ model="test-model",+ mcp_tools=_MustNotIterate(),+ mcp_clients=_MustNotIterate(),+ )++ assert [tool.spec.name for tool in resolved.instances] == ["shared"]+ assert resolved.mcp_clients == []diff --git a/tests/cli/test_serve_single_build.py b/tests/cli/test_serve_single_build.pyindex 1a0fddf8..0453d49c 100644--- a/tests/cli/test_serve_single_build.py+++ b/tests/cli/test_serve_single_build.py@@ -101,6 +101,7 @@ def _run_serve(tmp_path, monkeypatch, *, build_spy, set_system_spy):(``uvicorn.run`` is a no-op) and no real engine is contacted."""from openjarvis.core.config import JarvisConfig+ from openjarvis.core.registry import MemoryRegistry_repopulate_registries()@@ -112,6 +113,9 @@ def _run_serve(tmp_path, monkeypatch, *, build_spy, set_system_spy):config.sessions.enabled = Trueconfig.sessions.db_path = str(tmp_path / "sessions.db")config.memory.db_path = str(tmp_path / "memory.db")+ # Disabling prompt-context injection must not disable the backend needed+ # by explicitly configured memory tools in managed-agent ticks.+ config.agent.context_from_memory = Falseconfig.telemetry.enabled = Falseconfig.traces.enabled = Falseconfig.channel.enabled = False@@ -122,6 +126,16 @@ def _run_serve(tmp_path, monkeypatch, *, build_spy, set_system_spy):config.intelligence.default_model = "test-model"engine = _fake_engine()+ # Keep this wiring test independent of the optional native memory runtime.+ # The assertion is that serve resolves and passes a backend even when+ # prompt-context injection is disabled, not that SQLite itself works.+ memory_backend = MagicMock(name="memory_backend")+ monkeypatch.setattr(MemoryRegistry, "contains", MagicMock(return_value=True))+ monkeypatch.setattr(+ MemoryRegistry,+ "create",+ MagicMock(return_value=memory_backend),+ )monkeypatch.setattr(serve_mod, "load_config", lambda *a, **k: config)monkeypatch.setattr(serve_mod, "get_engine", lambda *a, **k: ("mock", engine))diff --git a/tests/mcp/test_client.py b/tests/mcp/test_client.pyindex 0ee692fb..c23bd868 100644--- a/tests/mcp/test_client.py+++ b/tests/mcp/test_client.py@@ -2,10 +2,15 @@from __future__ import annotations+import threading+import time+from concurrent.futures import ThreadPoolExecutor+from unittest.mock import MagicMock+import pytestfrom openjarvis.mcp.client import MCPClient-from openjarvis.mcp.protocol import MCPError+from openjarvis.mcp.protocol import MCPError, MCPResponsefrom openjarvis.mcp.server import MCPServerfrom openjarvis.mcp.transport import InProcessTransportfrom openjarvis.tools._stubs import ToolSpec@@ -101,3 +106,101 @@ class TestMCPClient:result = client.call_tool("think")# Think tool echoes empty thoughtassert result["isError"] is False++ def test_shared_client_serializes_transport_round_trips(self):+ """Concurrent agents cannot consume one another's MCP responses."""++ class _ConcurrencyProbeTransport:+ def __init__(self):+ self.active = 0+ self.max_active = 0+ self.lock = threading.Lock()++ def send(self, request):+ with self.lock:+ self.active += 1+ self.max_active = max(self.max_active, self.active)+ time.sleep(0.01)+ with self.lock:+ self.active -= 1+ return MCPResponse(result={"tools": []}, id=request.id)++ def send_notification(self, request):+ return None++ def close(self):+ return None++ transport = _ConcurrencyProbeTransport()+ shared_client = MCPClient(transport)++ with ThreadPoolExecutor(max_workers=8) as pool:+ list(pool.map(lambda _: shared_client.list_tools(), range(24)))++ assert transport.max_active == 1++ def test_close_interrupts_blocked_request_and_rejects_queued_request(self):+ """Shutdown reaches the transport without waiting on an in-flight call."""++ class _BlockingTransport:+ def __init__(self):+ self.send_started = threading.Event()+ self.send_released = threading.Event()+ self.close_called = threading.Event()+ self.send_count = 0++ def send(self, request):+ self.send_count += 1+ self.send_started.set()+ self.send_released.wait()+ raise RuntimeError("transport closed")++ def send_notification(self, request):+ return None++ def close(self):+ self.close_called.set()+ self.send_released.set()++ transport = _BlockingTransport()+ shared_client = MCPClient(transport)++ with ThreadPoolExecutor(max_workers=3) as pool:+ blocked_request = pool.submit(shared_client.list_tools)+ assert transport.send_started.wait(timeout=1)++ queued_request = pool.submit(shared_client.list_tools)+ close_call = pool.submit(shared_client.close)++ try:+ close_reached_transport = transport.close_called.wait(timeout=1)+ finally:+ # Keep the test failure-safe against a regression that makes+ # close wait behind the blocked request.+ transport.send_released.set()++ close_call.result(timeout=1)+ assert close_reached_transport+ with pytest.raises(RuntimeError, match="transport closed"):+ blocked_request.result(timeout=1)+ with pytest.raises(RuntimeError, match="MCP client is closed"):+ queued_request.result(timeout=1)++ assert transport.send_count == 1++ def test_close_retries_transport_cleanup_after_failure(self):+ """A failed close keeps requests blocked but permits cleanup retry."""++ transport = MagicMock()+ transport.close.side_effect = [RuntimeError("terminate timed out"), None]+ client = MCPClient(transport)++ with pytest.raises(RuntimeError, match="terminate timed out"):+ client.close()+ with pytest.raises(RuntimeError, match="MCP client is closed"):+ client.list_tools()++ client.close()+ client.close()++ assert transport.close.call_count == 2diff --git a/tests/mcp/test_discovery.py b/tests/mcp/test_discovery.pyindex 1bfde7cf..9dc15097 100644--- a/tests/mcp/test_discovery.py+++ b/tests/mcp/test_discovery.py@@ -2,6 +2,7 @@from __future__ import annotations+import jsonfrom unittest.mock import MagicMock, patchimport pytest@@ -181,6 +182,132 @@ class TestClientPersistence:assert len(builder._mcp_clients) == 3+def test_builder_retains_full_mcp_pool_for_managed_agents() -> None:+ """Global primary-agent filters must not trim managed-agent MCP tools."""++ from openjarvis.core.config import JarvisConfig+ from openjarvis.system import SystemBuilder++ config = JarvisConfig()+ config.tools.mcp.servers = json.dumps(+ [{"name": "test", "url": "http://localhost:8080/mcp"}]+ )+ external = _make_mock_tool("mcp_only")+ builder = SystemBuilder(config).tools(["native_only"])++ with (+ patch("openjarvis.mcp.server.MCPServer") as mcp_server_cls,+ patch.object(+ builder,+ "_discover_external_mcp",+ return_value=[external],+ ),+ ):+ mcp_server_cls.return_value.get_tools.return_value = []+ primary_tools = builder._resolve_tools(+ config,+ engine=MagicMock(),+ model="test-model",+ memory_backend=None,+ )++ assert primary_tools == []+ assert builder._mcp_tools == [external]+++def test_builder_global_mcp_disable_prevents_discovery() -> None:+ """A global MCP disable is honored by every managed-agent entry path."""++ from openjarvis.core.config import JarvisConfig+ from openjarvis.system import SystemBuilder++ config = JarvisConfig()+ config.tools.mcp.enabled = False+ config.tools.mcp.servers = json.dumps(+ [{"name": "disabled", "url": "http://localhost:8080/mcp"}]+ )+ builder = SystemBuilder(config)++ with (+ patch("openjarvis.mcp.server.MCPServer") as mcp_server_cls,+ patch.object(builder, "_discover_external_mcp") as discover,+ ):+ mcp_server_cls.return_value.get_tools.return_value = []+ builder._resolve_tools(+ config,+ engine=MagicMock(),+ model="test-model",+ memory_backend=None,+ )++ discover.assert_not_called()+ assert builder._mcp_tools == []+++def test_reused_builder_transfers_only_current_build_mcp_state() -> None:+ """Each built system exclusively owns its own MCP clients and tools."""++ from openjarvis.core.config import JarvisConfig+ from openjarvis.system import SystemBuilder++ config = JarvisConfig()+ config.telemetry.enabled = False+ config.traces.enabled = False+ config.skills.enabled = False+ config.agent_manager.enabled = False+ config.tools.mcp.servers = json.dumps(+ [{"name": "test", "url": "http://localhost:8080/mcp"}]+ )++ engine = MagicMock(spec=["health", "can_serve", "generate", "list_models", "close"])+ engine.health.return_value = True+ first_tool = _make_mock_tool("first_mcp_tool")+ second_tool = _make_mock_tool("second_mcp_tool")+ first_client = MagicMock()+ second_client = MagicMock()+ discoveries = iter([(first_tool, first_client), (second_tool, second_client)])++ builder = (+ SystemBuilder(config)+ .engine_instance(engine)+ .model("test-model")+ .tools([])+ .telemetry(False)+ .traces(False)+ .speech(False)+ )++ def _discover(_server_cfg):+ tool, client = next(discoveries)+ builder._mcp_clients.append(client)+ return [tool]++ with (+ patch.object(builder, "_discover_external_mcp", side_effect=_discover),+ patch.object(builder, "_resolve_memory", return_value=None),+ ):+ first_system = builder.build()+ assert first_system.mcp_tools == [first_tool]+ assert first_system._mcp_clients == [first_client]+ assert builder._mcp_tools == []+ assert builder._mcp_clients == []+ first_system.close()++ second_system = builder.build()++ try:+ assert second_system.mcp_tools == [second_tool]+ assert second_system._mcp_clients == [second_client]+ assert first_client not in second_system._mcp_clients+ assert builder._mcp_tools == []+ assert builder._mcp_clients == []+ finally:+ second_system.close()++ first_client.close.assert_called_once()+ second_client.close.assert_called_once()++class TestStringConfig:@patch(_PATCH_PROVIDER)@patch(_PATCH_CLIENT)diff --git a/tests/sdk/test_system.py b/tests/sdk/test_system.pyindex 4502ea47..79f0c138 100644--- a/tests/sdk/test_system.py+++ b/tests/sdk/test_system.py@@ -12,6 +12,34 @@ from openjarvis.system import JarvisSystem, SystemBuilderclass TestJarvisSystem:+ def test_new_fields_do_not_shift_existing_positional_arguments(self):+ """Adding mcp_tools must not reinterpret legacy positional calls."""+ config = JarvisConfig()+ bus = EventBus()+ engine = MagicMock()+ agent = MagicMock()+ tools = [MagicMock()]+ tool_executor = MagicMock()+ memory_backend = MagicMock()++ system = JarvisSystem(+ config,+ bus,+ engine,+ "mock",+ "test-model",+ agent,+ "simple",+ tools,+ tool_executor,+ memory_backend,+ )++ assert system.tools is tools+ assert system.tool_executor is tool_executor+ assert system.memory_backend is memory_backend+ assert system.mcp_tools == []+def test_ask_direct_mode(self):engine = MagicMock()engine.generate.return_value = {diff --git a/tests/server/test_agent_manager_routes.py b/tests/server/test_agent_manager_routes.pyindex 6dda4fbc..aded7532 100644--- a/tests/server/test_agent_manager_routes.py+++ b/tests/server/test_agent_manager_routes.py@@ -4,6 +4,8 @@ from __future__ import annotationsimport jsonimport tempfile+import threading+from concurrent.futures import ThreadPoolExecutorfrom pathlib import Pathfrom types import SimpleNamespacefrom unittest.mock import AsyncMock, MagicMock, patch@@ -602,3 +604,81 @@ class TestLightweightSystemEngineResolution:engine=MagicMock(), model="m", config=self._cfg(None, "llamacpp"))assert captured["key"] == "llamacpp"++ def test_caches_tool_memory_backend_when_prompt_context_is_disabled(+ self,+ monkeypatch,+ ):+ pytest.importorskip("fastapi")+ from openjarvis.server import agent_manager_routes as amr++ backend = object()+ resolver = MagicMock(return_value=backend)+ monkeypatch.setattr(amr, "_resolve_memory_backend", resolver)+ config = SimpleNamespace(+ agent=SimpleNamespace(context_from_memory=False),+ memory=SimpleNamespace(default_backend="sqlite", db_path="memory.db"),+ )+ runtime = SimpleNamespace(+ memory_backend=None,+ _owns_memory_backend=False,+ channel_backend=None,+ channel_bridge=None,+ knowledge_db_path=None,+ )++ system = amr._LightweightSystem(+ engine=MagicMock(),+ model="m",+ config=config,+ runtime=runtime,+ )++ resolver.assert_called_once_with(config)+ assert system.memory_backend is backend+ assert runtime.memory_backend is backend+ assert runtime._owns_memory_backend is True++ def test_memory_backend_lazy_init_is_synchronized(self, monkeypatch):+ pytest.importorskip("fastapi")+ from openjarvis.server import agent_manager_routes as amr++ backend = object()+ resolver_calls = 0+ calls_lock = threading.Lock()+ duplicate_entered = threading.Event()+ start = threading.Barrier(8)++ def _resolve(config):+ nonlocal resolver_calls+ with calls_lock:+ resolver_calls += 1+ call_number = resolver_calls+ if call_number > 1:+ duplicate_entered.set()+ # A check-then-create race lets another worker enter while the+ # first resolver is blocked here. The locked implementation times+ # out once, publishes the backend, and all other workers reuse it.+ if call_number == 1:+ duplicate_entered.wait(timeout=0.2)+ return backend++ monkeypatch.setattr(amr, "_resolve_memory_backend", _resolve)+ config = SimpleNamespace()+ runtime = SimpleNamespace(+ memory_backend=None,+ _owns_memory_backend=False,+ _managed_runtime_stopping=False,+ )++ def _get_backend():+ start.wait(timeout=2)+ return amr._get_or_create_memory_backend(runtime, config)++ with ThreadPoolExecutor(max_workers=8) as pool:+ results = list(pool.map(lambda _: _get_backend(), range(8)))++ assert resolver_calls == 1+ assert results == [backend] * 8+ assert runtime.memory_backend is backend+ assert runtime._owns_memory_backend is Truediff --git a/tests/server/test_deep_research_tools_wiring.py b/tests/server/test_deep_research_tools_wiring.pyindex f568471b..5de649af 100644--- a/tests/server/test_deep_research_tools_wiring.py+++ b/tests/server/test_deep_research_tools_wiring.py@@ -2,7 +2,9 @@from __future__ import annotations+import jsonfrom pathlib import Path+from types import SimpleNamespacefrom unittest.mock import MagicMockimport pytest@@ -15,6 +17,82 @@ except ImportError:HAS_FASTAPI = Falsefrom openjarvis.connectors.store import KnowledgeStore+from openjarvis.core.registry import ToolRegistry+from openjarvis.core.types import Role, ToolResult+from openjarvis.tools._stubs import BaseTool, ToolSpec+++class _ConfiguredResearchProbe(BaseTool):+ """Configured native tool used to exercise the Deep Research SSE path."""++ tool_id = "configured_research_probe_682"+ calls = 0++ @property+ def spec(self) -> ToolSpec:+ return ToolSpec(+ name=self.tool_id,+ description="Configured Deep Research probe",+ parameters={+ "type": "object",+ "properties": {"value": {"type": "string"}},+ "required": ["value"],+ },+ )++ def execute(self, **params) -> ToolResult:+ type(self).calls += 1+ return ToolResult(+ tool_name=self.tool_id,+ content=f"configured:{params['value']}",+ )+++class _MCPResearchProbe(BaseTool):+ """MCP-shaped adapter that must be merged into the same toolkit."""++ tool_id = "mcp_research_probe_682"++ @property+ def spec(self) -> ToolSpec:+ return ToolSpec(name=self.tool_id, description="MCP Deep Research probe")++ def execute(self, **params) -> ToolResult:+ return ToolResult(tool_name=self.tool_id, content="mcp")+++class _ScriptedDeepResearchEngine:+ """Call the configured probe once, then return a final answer."""++ def __init__(self) -> None:+ self.turns = 0+ self.advertised_names: list[str] = []+ self.observed_tool_result = ""++ def generate(self, messages, *, model, **kwargs):+ self.turns += 1+ self.advertised_names = [+ spec["function"]["name"] for spec in kwargs.get("tools", [])+ ]+ if self.turns == 1:+ return {+ "content": "",+ "tool_calls": [+ {+ "id": "call-configured-research-probe",+ "type": "function",+ "function": {+ "name": _ConfiguredResearchProbe.tool_id,+ "arguments": json.dumps({"value": "sentinel"}),+ },+ }+ ],+ "usage": {},+ }++ tool_messages = [message for message in messages if message.role is Role.TOOL]+ self.observed_tool_result = tool_messages[-1].content+ return {"content": "complete", "tool_calls": [], "usage": {}}@pytest.mark.skipif(not HAS_FASTAPI, reason="fastapi not installed")@@ -53,3 +131,111 @@ def test_deep_research_tools_returns_empty_when_no_db() -> None:)assert tools == []++[email protected](not HAS_FASTAPI, reason="fastapi not installed")+ "with_knowledge_db",+ [False, True],+ ids=["without-knowledge-db", "with-knowledge-db"],+)+async def test_server_deep_research_merges_and_executes_all_tool_sources(+ tmp_path: Path,+ with_knowledge_db: bool,+ monkeypatch,+) -> None:+ """Configured and MCP tools reach Deep Research with or without its DB."""++ from openjarvis.server import agent_manager_routes as routes++ start_worker = MagicMock(wraps=routes._start_managed_worker)+ monkeypatch.setattr(routes, "_start_managed_worker", start_worker)++ db_path = tmp_path / "knowledge.db"+ if with_knowledge_db:+ store = KnowledgeStore(str(db_path))+ store.store("test content", source="test", doc_type="note")+ store.close()++ if not ToolRegistry.contains(_ConfiguredResearchProbe.tool_id):+ ToolRegistry.register_value(+ _ConfiguredResearchProbe.tool_id,+ _ConfiguredResearchProbe,+ )+ _ConfiguredResearchProbe.calls = 0++ mcp_tool = _MCPResearchProbe()+ app_state = SimpleNamespace(+ config=SimpleNamespace(memory_files=None, system_prompt=None),+ memory_backend=None,+ channel_backend=None,+ channel_bridge=None,+ knowledge_db_path=str(db_path),+ _mcp_clients=[object()],+ _mcp_tools_cache=(+ [mcp_tool.to_openai_function()],+ {mcp_tool.spec.name: mcp_tool},+ ),+ )+ manager = MagicMock()+ manager.list_messages.return_value = []+ engine = _ScriptedDeepResearchEngine()++ response = await routes._stream_managed_agent(+ manager=manager,+ agent_record={+ "id": "agent-deep-research-682",+ "name": "Deep Research Agent",+ "agent_type": "deep_research",+ "config": {+ "model": "test-model",+ "max_turns": 3,+ "tools": [_ConfiguredResearchProbe.tool_id],+ },+ },+ user_content="Use the configured research probe",+ message_id="message-deep-research-682",+ engine=engine,+ bus=None,+ app_state=app_state,+ )++ body_parts: list[str] = []+ async for part in response.body_iterator:+ body_parts.append(part.decode() if isinstance(part, bytes) else part)++ expected_names = {+ _ConfiguredResearchProbe.tool_id,+ _MCPResearchProbe.tool_id,+ }+ knowledge_names = {+ "knowledge_search",+ "knowledge_sql",+ "scan_chunks",+ "think",+ }+ if with_knowledge_db:+ expected_names.update(knowledge_names)++ assert set(engine.advertised_names) == expected_names+ assert len(engine.advertised_names) == len(expected_names)+ assert not with_knowledge_db or knowledge_names.issubset(engine.advertised_names)+ assert with_knowledge_db or knowledge_names.isdisjoint(engine.advertised_names)+ assert engine.turns == 2+ assert _ConfiguredResearchProbe.calls == 1+ assert engine.observed_tool_result == "configured:sentinel"+ assert "data: [DONE]" in "".join(body_parts)+ start_worker.assert_called_once()+ assert start_worker.call_args.kwargs["name"].startswith(+ "managed-agent-deep-research-"+ )+ assert app_state._managed_workers == set()++ manager.store_agent_response.assert_called_once()+ stored = manager.store_agent_response.call_args+ assert stored.args[:2] == ("agent-deep-research-682", "complete")+ persisted_calls = stored.kwargs["tool_calls"]+ assert persisted_calls[0]["tool"] == _ConfiguredResearchProbe.tool_id+ assert persisted_calls[0]["result"] == "configured:sentinel"+ assert persisted_calls[0]["success"] is Truediff --git a/tests/server/test_managed_agent_resolved_tools.py b/tests/server/test_managed_agent_resolved_tools.pynew file mode 100644index 00000000..c1ca4f66--- /dev/null+++ b/tests/server/test_managed_agent_resolved_tools.py@@ -0,0 +1,302 @@+"""SSE regression coverage for canonical managed-agent tool resolution."""++from __future__ import annotations++import json+from types import SimpleNamespace+from unittest.mock import MagicMock++import pytest++pytest.importorskip("fastapi")++from openjarvis.core.registry import ToolRegistry # noqa: E402+from openjarvis.core.types import Role, ToolResult # noqa: E402+from openjarvis.engine._stubs import StreamChunk # noqa: E402+from openjarvis.tools._stubs import BaseTool, ToolSpec # noqa: E402+++class _StatefulConfiguredTool(BaseTool):+ """A tool whose result identifies the exact instance that executed."""++ tool_id = "stateful_probe"+ instances: list["_StatefulConfiguredTool"] = []++ def __init__(self) -> None:+ self.instance_id = len(self.instances) + 1+ self.calls = 0+ self.instances.append(self)++ @property+ def spec(self) -> ToolSpec:+ return ToolSpec(+ name="stateful_probe",+ description=f"configured-instance-{self.instance_id}",+ parameters={+ "type": "object",+ "properties": {"value": {"type": "string"}},+ "required": ["value"],+ },+ )++ def execute(self, **params) -> ToolResult:+ self.calls += 1+ return ToolResult(+ tool_name=self.spec.name,+ content=(+ f"instance={self.instance_id};calls={self.calls};"+ f"value={params['value']}"+ ),+ )+++class _CollidingMCPTool(BaseTool):+ """An MCP-shaped collision that must lose to the configured native tool."""++ tool_id = "mcp_stateful_probe"++ def __init__(self) -> None:+ self.calls = 0++ @property+ def spec(self) -> ToolSpec:+ return ToolSpec(+ name="stateful_probe",+ description="mcp-collision",+ parameters={"type": "object", "properties": {}},+ )++ def execute(self, **params) -> ToolResult:+ self.calls += 1+ return ToolResult(tool_name=self.spec.name, content="wrong MCP instance")+++class _ToolCallingEngine:+ """Advertise the toolkit, request one call, then observe its result."""++ def __init__(+ self,+ tool_name: str = "stateful_probe",+ arguments: dict | None = None,+ ) -> None:+ self.tool_name = tool_name+ self.arguments = arguments or {"value": "sentinel"}+ self.turns = 0+ self.advertised_specs: list[dict] = []+ self.observed_tool_result = ""++ async def stream_full(self, messages, *, model, **kwargs):+ self.turns += 1+ self.advertised_specs = list(kwargs.get("tools", []))++ if self.turns == 1:+ yield StreamChunk(+ tool_calls=[+ {+ "index": 0,+ "id": f"call-{self.tool_name}",+ "type": "function",+ "function": {+ "name": self.tool_name,+ "arguments": json.dumps(self.arguments),+ },+ }+ ],+ finish_reason="tool_calls",+ )+ return++ tool_messages = [message for message in messages if message.role is Role.TOOL]+ self.observed_tool_result = tool_messages[-1].content+ yield StreamChunk(content="complete")+ yield StreamChunk(finish_reason="stop")+++class _FinalOnlyEngine:+ async def stream_full(self, messages, *, model, **kwargs):+ yield StreamChunk(content="complete")+ yield StreamChunk(finish_reason="stop")+++async def test_sse_advertises_and_executes_the_same_resolved_tool_instance() -> None:+ """The schema and dispatch map must come from one first-wins toolkit."""++ from openjarvis.server.agent_manager_routes import _stream_managed_agent++ _StatefulConfiguredTool.instances.clear()+ ToolRegistry.register_value("stateful_probe", _StatefulConfiguredTool)++ colliding_mcp = _CollidingMCPTool()+ mcp_spec = colliding_mcp.to_openai_function()+ app_state = SimpleNamespace(+ config=SimpleNamespace(memory_files=None, system_prompt=None),+ memory_backend=None,+ channel_backend=None,+ channel_bridge=None,+ _mcp_clients=[object()],+ _mcp_tools_cache=(+ [mcp_spec],+ {"stateful_probe": colliding_mcp},+ ),+ )+ manager = MagicMock()+ manager.list_messages.return_value = []+ engine = _ToolCallingEngine()+ custom_spec = {+ "type": "function",+ "function": {+ "name": "stateful_probe",+ "description": "custom configured schema",+ "parameters": {+ "type": "object",+ "properties": {"value": {"type": "string"}},+ "required": ["value"],+ },+ },+ }++ response = await _stream_managed_agent(+ manager=manager,+ agent_record={+ "id": "agent-stateful",+ "name": "Stateful Agent",+ "agent_type": "simple",+ "config": {+ "model": "test-model",+ "max_turns": 3,+ "tools": [custom_spec],+ },+ },+ user_content="Use the stateful probe",+ message_id="message-stateful",+ engine=engine,+ bus=None,+ app_state=app_state,+ )++ body_parts: list[str] = []+ async for part in response.body_iterator:+ body_parts.append(part.decode() if isinstance(part, bytes) else part)++ assert engine.turns == 2+ assert len(_StatefulConfiguredTool.instances) == 1+ configured_instance = _StatefulConfiguredTool.instances[0]+ assert configured_instance.calls == 1+ assert colliding_mcp.calls == 0++ advertised = [+ spec+ for spec in engine.advertised_specs+ if spec.get("function", {}).get("name") == "stateful_probe"+ ]+ assert len(advertised) == 1+ assert advertised[0] is custom_spec+ assert advertised[0]["function"]["description"] == "custom configured schema"+ assert engine.observed_tool_result == "instance=1;calls=1;value=sentinel"+ assert "data: [DONE]" in "".join(body_parts)+++async def test_sse_mcp_opt_out_skips_discovery(monkeypatch) -> None:+ """Opting out skips request-local discovery and hides MCP specs."""++ from openjarvis.server import agent_manager_routes as routes++ discovery = MagicMock(side_effect=AssertionError("MCP discovery must not run"))+ monkeypatch.setattr(routes, "_get_mcp_tools", discovery)+ manager = MagicMock()+ manager.list_messages.return_value = []+ app_state = SimpleNamespace(+ config=SimpleNamespace(memory_files=None, system_prompt=None),+ memory_backend=None,+ channel_backend=None,+ channel_bridge=None,+ )++ response = await routes._stream_managed_agent(+ manager=manager,+ agent_record={+ "id": "agent-no-mcp",+ "name": "No MCP",+ "agent_type": "simple",+ "config": {"model": "test-model", "mcp_tools": False},+ },+ user_content="Answer directly",+ message_id="message-no-mcp",+ engine=_FinalOnlyEngine(),+ bus=None,+ app_state=app_state,+ )++ async for _ in response.body_iterator:+ pass++ discovery.assert_not_called()+++async def test_sse_memory_tools_resolve_backend_when_context_injection_is_off(+ monkeypatch,+) -> None:+ """Prompt context opt-out must not disable explicit memory tools."""++ from openjarvis.server import agent_manager_routes as routes+ from openjarvis.tools.storage_tools import MemoryStoreTool++ if not ToolRegistry.contains("memory_store"):+ ToolRegistry.register_value("memory_store", MemoryStoreTool)++ backend = MagicMock()+ backend.store.return_value = "doc-1"+ resolver = MagicMock(return_value=backend)+ monkeypatch.setattr(routes, "_resolve_memory_backend", resolver)++ manager = MagicMock()+ manager.list_messages.return_value = []+ app_config = SimpleNamespace(+ memory_files=None,+ system_prompt=None,+ agent=SimpleNamespace(context_from_memory=False),+ memory=SimpleNamespace(default_backend="sqlite", db_path="memory.db"),+ )+ app_state = SimpleNamespace(+ config=app_config,+ memory_backend=None,+ channel_backend=None,+ channel_bridge=None,+ _mcp_clients=[],+ _mcp_tools_cache=([], {}),+ )+ engine = _ToolCallingEngine(+ tool_name="memory_store",+ arguments={"content": "remember me"},+ )++ response = await routes._stream_managed_agent(+ manager=manager,+ agent_record={+ "id": "agent-memory-tool",+ "name": "Memory Tool Agent",+ "agent_type": "simple",+ "config": {+ "model": "test-model",+ "max_turns": 3,+ "tools": ["memory_store"],+ },+ },+ user_content="Remember this",+ message_id="message-memory-tool",+ engine=engine,+ bus=None,+ app_state=app_state,+ )++ async for _ in response.body_iterator:+ pass++ resolver.assert_called_once_with(app_config)+ assert app_state.memory_backend is backend+ assert app_state._owns_memory_backend is True+ backend.store.assert_called_once_with("remember me", source="")+ assert engine.observed_tool_result == "Stored as doc-1"diff --git a/tests/server/test_mcp_tools_cache.py b/tests/server/test_mcp_tools_cache.pyindex d3bcdfa4..ccc6b26a 100644--- a/tests/server/test_mcp_tools_cache.py+++ b/tests/server/test_mcp_tools_cache.py@@ -3,6 +3,7 @@from __future__ import annotationsimport json+import threadingfrom unittest.mock import MagicMock, patchimport pytest@@ -118,7 +119,7 @@ def test_does_not_cache_empty_results(mock_load_config: MagicMock):with (patch("openjarvis.mcp.transport.StreamableHTTPTransport"),- patch("openjarvis.mcp.client.MCPClient"),+ patch("openjarvis.mcp.client.MCPClient") as MockClient,patch("openjarvis.tools.mcp_adapter.MCPToolProvider") as MockProvider,):# First call: discovery returns empty@@ -127,6 +128,8 @@ def test_does_not_cache_empty_results(mock_load_config: MagicMock):tools1, _ = _get_mcp_tools(app_state)assert len(tools1) == 0+ MockClient.return_value.close.assert_called_once_with()+ assert getattr(app_state, "_mcp_clients", []) == []# Verify no cache was set (empty result)assert getattr(app_state, "_mcp_tools_cache", None) is None@@ -152,3 +155,298 @@ def test_handles_config_load_failure(mock_load_config: MagicMock):assert tools == []assert adapters == {}+++@patch("openjarvis.core.config.load_config")+def test_uses_preloaded_full_system_pool(mock_load_config: MagicMock):+ """Server and scheduled paths reuse one unfiltered MCP discovery."""++ from openjarvis.server.agent_manager_routes import _get_mcp_tools++ adapter = _make_adapter("preloaded_tool")+ app_state = _FakeAppState()+ app_state.mcp_tools = [adapter]++ tools, adapters = _get_mcp_tools(app_state)++ mock_load_config.assert_not_called()+ assert tools[0]["function"]["name"] == "preloaded_tool"+ assert adapters == {"preloaded_tool": adapter}+++@patch("openjarvis.core.config.load_config")+def test_preloaded_duplicate_names_are_first_wins(mock_load_config: MagicMock):+ """SSE and executor paths choose the same adapter on name collisions."""++ from openjarvis.server.agent_manager_routes import _get_mcp_tools++ first = _make_adapter("duplicate")+ second = _make_adapter("duplicate")+ app_state = _FakeAppState()+ app_state.mcp_tools = [first, second]++ tools, adapters = _get_mcp_tools(app_state)++ mock_load_config.assert_not_called()+ assert len(tools) == 1+ assert adapters == {"duplicate": first}+++def test_app_shutdown_stops_scheduler_before_closing_shared_mcp_clients() -> None:+ """Shutdown quiesces and drains every user of the shared MCP pool."""++ from fastapi.testclient import TestClient++ from openjarvis.core.config import JarvisConfig+ from openjarvis.server.agent_manager_routes import _start_managed_worker+ from openjarvis.server.app import create_app++ events: list[str] = []+ release_worker = threading.Event()+ worker_finished = threading.Event()++ class _Scheduler:+ def request_stop(self):+ events.append("scheduler-stop")++ def wait_stopped(self, timeout=10):+ events.append("scheduler-wait")+ return True++ scheduler = _Scheduler()+ mcp_client = MagicMock()+ memory_backend = MagicMock()+ channel_bridge = MagicMock()++ def _close_mcp():+ events.append("mcp")+ release_worker.set()++ mcp_client.close.side_effect = _close_mcp+ memory_backend.close.side_effect = lambda: events.append("memory")+ channel_bridge.disconnect.side_effect = lambda: events.append("channel")+ config = JarvisConfig()+ config.analytics.enabled = False+ config.traces.enabled = False++ app = create_app(+ MagicMock(),+ "test-model",+ config=config,+ channel_bridge=channel_bridge,+ agent_scheduler=scheduler,+ mcp_clients=[mcp_client],+ memory_backend=memory_backend,+ own_memory_backend=True,+ )++ def _worker():+ release_worker.wait(timeout=2)+ events.append("worker-finished")+ worker_finished.set()++ _start_managed_worker(app.state, _worker, name="test-managed-worker")++ with TestClient(app):+ pass++ mcp_client.close.assert_called_once_with()+ memory_backend.close.assert_called_once_with()+ channel_bridge.disconnect.assert_called_once_with()+ assert worker_finished.is_set()+ assert app.state.memory_backend is None+ assert app.state._owns_memory_backend is False+ assert app.state._managed_runtime_stopping is True+ assert app.state._managed_workers == set()+ assert events.index("channel") < events.index("mcp")+ assert events.index("scheduler-stop") < events.index("mcp")+ assert events.index("mcp") < events.index("worker-finished")+ assert events.index("worker-finished") < events.index("memory")+ with pytest.raises(RuntimeError, match="shutting down"):+ _start_managed_worker(app.state, lambda: None, name="too-late-worker")+++def test_shutdown_interrupts_mcp_client_during_lazy_initialization() -> None:+ """A client is registered before initialize() can block on transport I/O."""++ from fastapi.testclient import TestClient++ from openjarvis.core.config import JarvisConfig+ from openjarvis.server.agent_manager_routes import (+ _get_mcp_tools,+ _start_managed_worker,+ )+ from openjarvis.server.app import create_app++ initialize_started = threading.Event()+ initialize_released = threading.Event()+ discovery_finished = threading.Event()++ class _BlockingClient:+ def __init__(self):+ self.closed = False+ self.close_calls = 0++ def initialize(self):+ initialize_started.set()+ initialize_released.wait(timeout=2)+ if self.closed:+ raise RuntimeError("transport closed during initialize")++ def close(self):+ self.close_calls += 1+ self.closed = True+ initialize_released.set()++ client = _BlockingClient()+ config = JarvisConfig()+ config.analytics.enabled = False+ config.traces.enabled = False+ app = create_app(MagicMock(), "test-model", config=config)+ mcp_config = _make_config(+ servers_json=json.dumps([{"name": "blocking", "url": "http://localhost:9999"}])+ )++ def _discover():+ try:+ _get_mcp_tools(app.state)+ finally:+ discovery_finished.set()++ with (+ patch("openjarvis.core.config.load_config", return_value=mcp_config),+ patch("openjarvis.mcp.transport.StreamableHTTPTransport"),+ patch("openjarvis.mcp.client.MCPClient", return_value=client),+ ):+ _start_managed_worker(+ app.state,+ _discover,+ name="blocking-mcp-discovery",+ )+ assert initialize_started.wait(timeout=2)+ with app.state._mcp_clients_lock:+ assert client in app.state._mcp_clients++ with TestClient(app):+ pass++ assert client.close_calls >= 1+ assert discovery_finished.is_set()+ assert app.state._managed_workers == set()+ assert getattr(app.state, "_mcp_tools_cache", None) is None+++def test_app_shutdown_closes_lazily_created_memory_backend(monkeypatch) -> None:+ """A backend opened by a managed route is owned and closed by the app."""++ from fastapi.testclient import TestClient++ from openjarvis.core.config import JarvisConfig+ from openjarvis.server import agent_manager_routes as routes+ from openjarvis.server.app import create_app++ backend = MagicMock()+ monkeypatch.setattr(routes, "_resolve_memory_backend", lambda config: backend)+ config = JarvisConfig()+ config.analytics.enabled = False+ config.traces.enabled = False+ app = create_app(MagicMock(), "test-model", config=config)++ assert routes._get_or_create_memory_backend(app.state, config) is backend+ assert app.state._owns_memory_backend is True++ with TestClient(app):+ pass++ backend.close.assert_called_once_with()+ assert app.state.memory_backend is None+++def test_app_shutdown_keeps_owned_memory_open_for_live_worker(monkeypatch) -> None:+ """A timed-out worker must never resume against a closed backend."""++ from fastapi.testclient import TestClient++ from openjarvis.core.config import JarvisConfig+ from openjarvis.server import app as app_module+ from openjarvis.server.agent_manager_routes import _start_managed_worker++ monkeypatch.setattr(app_module, "_MANAGED_SHUTDOWN_GRACE_SECONDS", 0.01)+ monkeypatch.setattr(app_module, "_MANAGED_SHUTDOWN_DRAIN_SECONDS", 0.01)++ release_worker = threading.Event()+ worker_holds_memory_lock = threading.Event()+ shutdown_finished = threading.Event()+ shutdown_errors: list[BaseException] = []+ backend = MagicMock()+ config = JarvisConfig()+ config.analytics.enabled = False+ config.traces.enabled = False+ app = app_module.create_app(+ MagicMock(),+ "test-model",+ config=config,+ memory_backend=backend,+ own_memory_backend=True,+ )++ def _hold_memory_lock():+ with app.state._memory_backend_lock:+ worker_holds_memory_lock.set()+ release_worker.wait(timeout=2)++ worker = _start_managed_worker(+ app.state,+ _hold_memory_lock,+ name="memory-using-straggler",+ )+ assert worker_holds_memory_lock.wait(timeout=2)++ def _shutdown_app():+ try:+ with TestClient(app):+ pass+ except BaseException as exc:+ shutdown_errors.append(exc)+ finally:+ shutdown_finished.set()++ shutdown_thread = threading.Thread(target=_shutdown_app, daemon=True)+ shutdown_thread.start()++ try:+ assert shutdown_finished.wait(timeout=1)+ assert shutdown_errors == []+ backend.close.assert_not_called()+ assert app.state.memory_backend is backend+ assert app.state._owns_memory_backend is True+ finally:+ release_worker.set()+ worker.join(timeout=2)+ shutdown_thread.join(timeout=2)+++def test_app_shutdown_leaves_borrowed_memory_backend_open() -> None:+ """An injected backend remains owned by its caller unless opted in."""++ from fastapi.testclient import TestClient++ from openjarvis.core.config import JarvisConfig+ from openjarvis.server.app import create_app++ backend = MagicMock()+ config = JarvisConfig()+ config.analytics.enabled = False+ config.traces.enabled = False+ app = create_app(+ MagicMock(),+ "test-model",+ config=config,+ memory_backend=backend,+ )++ with TestClient(app):+ pass++ backend.close.assert_not_called()+ assert app.state.memory_backend is backend