talkops-opscloud 0.3.0b2__tar.gz → 0.3.0b4__tar.gz

{talkops_opscloud-0.3.0b2 → talkops_opscloud-0.3.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: talkops-opscloud
-Version: 0.3.0b2
+Version: 0.3.0b4
 Summary: Extensible Terminal Multi-Agent Framework for Cloud Operations & DevOps Coding
 License-File: LICENSE
 Requires-Python: >=3.12

{talkops_opscloud-0.3.0b2 → talkops_opscloud-0.3.0b4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "talkops-opscloud"
-version = "0.3.0b2"
+version = "0.3.0b4"
 description = "Extensible Terminal Multi-Agent Framework for Cloud Operations & DevOps Coding"
 readme = "README.md"
 requires-python = ">=3.12"

{talkops_opscloud-0.3.0b2 → talkops_opscloud-0.3.0b4}/src/opscloud/agent/factory.py

@@ -707,9 +707,9 @@ def create_opscloud_agent(
     from deepagents.middleware.subagents import GENERAL_PURPOSE_SUBAGENT, SubAgent
 
     compiled_subagents: list[SubAgent] = []
-    base_subagent_tools = [t for t in all_tools if t not in mcp_tools_list]
     for name, subagent_meta in subagent_by_name.items():
         model_spec = subagent_meta.get("model")
+        has_explicit_model = bool(model_spec)
         sub_prompt = subagent_meta.get("system_prompt") or ""
         subagent_dict: dict[str, Any] = {
             "name": subagent_meta.get("name") or name,
@@ -717,30 +717,14 @@ def create_opscloud_agent(
             "system_prompt": sub_prompt,
         }
         if model_spec:
-            try:
-                sub_model_res = create_model(model_spec)
-                subagent_dict["model"] = sub_model_res.model
-            except Exception as e:
-                logger.warning("Failed to resolve model %s for subagent %s: %s", model_spec, name, e)
+            subagent_dict["model"] = model_spec
 
         subagent_name = subagent_meta.get("name") or name
         subagent_path = subagent_meta.get("path")
         custom_mw = subagent_meta.get("middleware")
 
-        # Build per-subagent MCP config and tools for this subagent
-        from opscloud.plugins.adapters.mcp import prepare_subagent_mcp
-
-        servers, subagent_mcp_tools, sub_mcp_server_infos = prepare_subagent_mcp(
-            subagent_name, subagent_meta, project_scope_root
-        )
-
-        if subagent_mcp_tools:
-            subagent_dict["tools"] = [*base_subagent_tools, *subagent_mcp_tools]
-        else:
-            subagent_dict["tools"] = list(base_subagent_tools)
-
         sub_middleware = _subagent_cli_middleware(
-            has_explicit_model=bool(model_spec),
+            has_explicit_model=has_explicit_model,
             assistant_id=assistant_id,
             subagent_name=subagent_name,
             subagent_meta=subagent_meta,
@@ -754,11 +738,8 @@ def create_opscloud_agent(
             worktree_root=effective_cwd,
             subagent_path=subagent_path if subagent_path else None,
             custom_middleware=custom_mw if isinstance(custom_mw, list) else None,
-            mcp_server_info=sub_mcp_server_infos or None,
-            mcp_config=servers or None,
-            mcp_tools=subagent_mcp_tools or None,
             backend=composite_backend,
-            model=subagent_dict.get("model") or active_model,
+            model=active_model,
         )
         if sub_middleware:
             subagent_dict["middleware"] = sub_middleware
@@ -767,10 +748,9 @@ def create_opscloud_agent(
 
         compiled_subagents.append(cast(SubAgent, subagent_dict))
         logger.info(
-            "Compiled subagent '%s' (tools: %d)",
+            "Registered declarative subagent '%s'",
             subagent_name,
-            len(subagent_dict.get("tools", [])),
-            extra={"subagent": subagent_name, "tools_count": len(subagent_dict.get("tools", []))},
+            extra={"subagent": subagent_name},
         )
 
     if not any(sub.get("name") == GENERAL_PURPOSE_SUBAGENT["name"] for sub in compiled_subagents):
@@ -793,7 +773,6 @@ def create_opscloud_agent(
             "name": gp_name,
             "description": gp_description,
             "system_prompt": gp_system_prompt,
-            "tools": list(base_subagent_tools),
             "middleware": gp_middleware,
         }
         if interrupt_on is not None:
@@ -810,7 +789,7 @@ def create_opscloud_agent(
                 },
             )
         logger.info(
-            "Compiled subagent '%s'",
+            "Registered declarative subagent '%s'",
             gp_name,
             extra={"subagent": gp_name},
         )

{talkops_opscloud-0.3.0b2 → talkops_opscloud-0.3.0b4}/src/opscloud/server/server.py

@@ -132,6 +132,8 @@ class ServerProcess:
         server_log_level = getattr(self.config, "server_log_level", "WARNING") or "WARNING"
         # Silence noisy startup/profiler heartbeats in LangGraph API by defaulting LOG_LEVEL to WARNING
         env.setdefault("LOG_LEVEL", server_log_level)
+        # Prevent blockbuster from raising BlockingError during model/SDK execution in ASGI server
+        env["LANGGRAPH_ALLOW_BLOCKING"] = "true"
 
         cmd = [
             sys.executable,
@@ -144,6 +146,7 @@ class ServerProcess:
             str(self.port),
             "--no-browser",
             "--no-reload",
+            "--allow-blocking",
             "--config",
             str(self.runtime_dir / "langgraph.json"),
             "--server-log-level",
@@ -198,23 +201,42 @@ class ServerProcess:
 
     def wait_for_graph_ready(self, graph_name: str = "agent", timeout: float = 30.0) -> None:
         """Resolve the served graph once so lazy startup failures surface immediately."""
+        if self.process is None:
+            raise RuntimeError("Server process is not running")
+
         deadline = time.monotonic() + timeout
         graph_url = f"{self.url}/assistants/{graph_name}/graph"
 
         while time.monotonic() < deadline:
-            if self.process and self.process.poll() is not None:
+            if self.process.poll() is not None:
                 err = self._read_log_tail()
-                raise RuntimeError(f"Server exited prematurely with code {self.process.returncode}:\n{err}")
+                raise RuntimeError(f"Server process exited with code {self.process.returncode}:\n{err}")
+
+            remaining = max(0.1, deadline - time.monotonic())
             try:
-                resp = httpx.get(graph_url, timeout=2.0)
-                if resp.status_code == 200:
-                    logger.info("Server graph %r is ready at %s", graph_name, self.url)
-                    return
-                elif resp.status_code == 404 and graph_name == "agent":
-                    graph_name = "opscloud"
-                    graph_url = f"{self.url}/assistants/{graph_name}/graph"
-            except Exception:
-                time.sleep(0.2)
+                resp = httpx.get(graph_url, timeout=remaining)
+            except (httpx.TransportError, httpx.TimeoutException, OSError) as exc:
+                err = self._read_log_tail()
+                if self.process.poll() is not None:
+                    msg = f"Server process exited with code {self.process.returncode}:\n{err}"
+                else:
+                    msg = f"Server graph '{graph_name}' did not initialize within {timeout}s:\n{err}"
+                raise RuntimeError(msg) from exc
+
+            if resp.status_code == 200:
+                logger.info("Server graph %r is ready at %s", graph_name, self.url)
+                return
+            elif resp.status_code == 404 and graph_name == "agent":
+                graph_name = "opscloud"
+                graph_url = f"{self.url}/assistants/{graph_name}/graph"
+                continue
+
+            err = self._read_log_tail()
+            msg = f"Server graph '{graph_name}' failed readiness check (status: {resp.status_code}):\n{err}"
+            raise RuntimeError(msg)
+
+        err = self._read_log_tail()
+        raise RuntimeError(f"Server graph '{graph_name}' did not initialize within {timeout}s:\n{err}")
 
     def _stop_process(self) -> None:
         """Stop only the server subprocess and its log file handle."""

talkops_opscloud-0.3.0b4/src/opscloud/server/server_graph.py

@@ -0,0 +1,123 @@
+"""Server-side graph entry point for `langgraph dev`.
+
+Follows the reference implementation in `reference/dcode/server_graph.py` by using
+a closure-managed `ServerRuntime` factory to build and cache all server runtime resources.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+import os
+import sys
+from typing import Any, NamedTuple
+
+from opscloud.backend.composite import OpsCloudCompositeBackend
+from opscloud.server._server_config import ServerConfig
+from opscloud.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ServerRuntime(NamedTuple):
+    """The one-per-process result with named slots preventing transposition."""
+
+    agent: Any
+    """Compiled LangGraph agent graph served as `agent`."""
+
+    backend: OpsCloudCompositeBackend
+    """Composite backend the agent and its operations were built with."""
+
+    offload: Any | None = None
+    """Server-owned thread offload operation bound to backend."""
+
+    mcp_server_info: list[Any] | None = None
+    """Workspace-scoped MCP metadata for the interactive client."""
+
+
+async def _make_graphs() -> ServerRuntime:
+    """Create the OpsCloud agent graph and its composite backend."""
+    config = ServerConfig.from_env()
+
+    if config.cwd:
+        os.environ["OPSCLOUD_SERVER_CWD"] = config.cwd
+    if config.project_root:
+        os.environ["OPSCLOUD_SERVER_PROJECT_ROOT"] = config.project_root
+
+    from opscloud.project_utils import get_server_project_context
+
+    project_context = get_server_project_context()
+
+    if config.aws_profile:
+        os.environ["AWS_PROFILE"] = config.aws_profile
+    if config.aws_region:
+        os.environ["AWS_REGION"] = config.aws_region
+    if config.aws_profile or config.aws_region:
+        from opscloud.config.settings import sync_aws_env_aliases
+
+        sync_aws_env_aliases()
+
+    if config.read_only:
+        os.environ["OPSCLOUD_READ_ONLY"] = "true"
+    if config.shell_allow_list:
+        os.environ["OPSCLOUD_SHELL_ALLOW_LIST"] = ",".join(config.shell_allow_list)
+
+    from opscloud.model.factory import create_model
+
+    model_res = await asyncio.to_thread(create_model, config.model)
+
+    effective_cwd = project_context.user_cwd if project_context else config.cwd
+
+    def _create_cli_graphs_sync() -> ServerRuntime:
+        from opscloud.agent.factory import create_opscloud_agent
+
+        agent, composite_backend = create_opscloud_agent(
+            model=model_res.model,
+            assistant_id=config.assistant_id,
+            system_prompt=config.system_prompt,
+            interactive=config.interactive,
+            auto_approve=config.auto_approve,
+            enable_shell=config.enable_shell,
+            cwd=effective_cwd,
+            project_context=project_context,
+        )
+        return ServerRuntime(
+            agent=agent,
+            backend=composite_backend,
+        )
+
+    return await asyncio.to_thread(_create_cli_graphs_sync)
+
+
+def _build_runtime_factory(
+    builder: Callable[[], Awaitable[ServerRuntime]] | None = None,
+) -> Callable[[], Awaitable[ServerRuntime]]:
+    """Build the cached factory for all server-owned runtime resources.
+
+    The cache lives in this closure rather than in module-level mutable globals,
+    matching reference/dcode/server_graph.py.
+    """
+    runtime: ServerRuntime | None = None
+    lock = asyncio.Lock()
+
+    async def get_runtime() -> ServerRuntime:
+        nonlocal runtime
+        if runtime is None:
+            async with lock:
+                if runtime is None:
+                    runtime = await (builder or _make_graphs)()
+        return runtime
+
+    return get_runtime
+
+
+_get_runtime = _build_runtime_factory()
+
+
+async def make_graph() -> Any:
+    """Return the agent graph for `langgraph dev`.
+
+    Delegates to the cached runtime factory. The compiled graph is created
+    on first call and served in <1ms for subsequent requests without rebuild overhead.
+    """
+    return (await _get_runtime()).agent

{talkops_opscloud-0.3.0b2 → talkops_opscloud-0.3.0b4}/tests/unit_tests/test_server.py

@@ -155,3 +155,49 @@ def test_server_graph_factory_signature():
 
     classification = _classify_factory(make_graph)
     assert classification == {}
+
+
+def test_wait_for_graph_ready_single_request():
+    """Verify wait_for_graph_ready sends a single request with full remaining timeout."""
+    import httpx
+    from unittest.mock import MagicMock, patch
+
+    cfg = ServerConfig()
+    proc = ServerProcess(cfg, port=8123)
+    proc.process = MagicMock()
+    proc.process.poll.return_value = None
+
+    mock_resp = MagicMock()
+    mock_resp.status_code = 200
+
+    with patch("httpx.get", return_value=mock_resp) as mock_get:
+        proc.wait_for_graph_ready("agent", timeout=15.0)
+
+        # Must be called exactly once
+        assert mock_get.call_count == 1
+        call_url, call_kwargs = mock_get.call_args[0][0], mock_get.call_args[1]
+        assert call_url == f"{proc.url}/assistants/agent/graph"
+        # Timeout must be approximately 15.0s, not 2.0s
+        assert 14.0 <= call_kwargs["timeout"] <= 15.0
+
+
+def test_wait_for_graph_ready_fallback():
+    """Verify wait_for_graph_ready falls back from agent to opscloud on 404."""
+    import httpx
+    from unittest.mock import MagicMock, patch
+
+    cfg = ServerConfig()
+    proc = ServerProcess(cfg, port=8123)
+    proc.process = MagicMock()
+    proc.process.poll.return_value = None
+
+    resp_404 = MagicMock(status_code=404)
+    resp_200 = MagicMock(status_code=200)
+
+    with patch("httpx.get", side_effect=[resp_404, resp_200]) as mock_get:
+        proc.wait_for_graph_ready("agent", timeout=15.0)
+
+        assert mock_get.call_count == 2
+        assert mock_get.call_args_list[0][0][0] == f"{proc.url}/assistants/agent/graph"
+        assert mock_get.call_args_list[1][0][0] == f"{proc.url}/assistants/opscloud/graph"
+

{talkops_opscloud-0.3.0b2 → talkops_opscloud-0.3.0b4}/uv.lock

@@ -4844,7 +4844,7 @@ wheels = [
 
 [[package]]
 name = "talkops-opscloud"
-version = "0.3.0b2"
+version = "0.3.0b4"
 source = { editable = "." }
 dependencies = [
     { name = "agent-client-protocol" },

talkops_opscloud-0.3.0b2/src/opscloud/server/server_graph.py

@@ -1,79 +0,0 @@
-"""Server-side graph entry point for `langgraph dev`."""
-
-from __future__ import annotations
-
-import asyncio
-import os
-import sys
-from typing import Any
-
-from opscloud.server._server_config import ServerConfig
-from opscloud.utils.logger import get_logger
-
-logger = get_logger(__name__)
-
-
-def _make_graph_sync() -> Any:
-    """Synchronously create and compile the OpsCloud agent graph."""
-    from opscloud.agent.factory import create_opscloud_agent
-    from opscloud.model.factory import create_model
-    from opscloud.project_utils import get_server_project_context
-
-    config = ServerConfig.from_env()
-
-    if config.cwd:
-        os.environ["OPSCLOUD_SERVER_CWD"] = config.cwd
-    if config.project_root:
-        os.environ["OPSCLOUD_SERVER_PROJECT_ROOT"] = config.project_root
-
-    project_context = get_server_project_context()
-
-    if config.aws_profile:
-        os.environ["AWS_PROFILE"] = config.aws_profile
-    if config.aws_region:
-        os.environ["AWS_REGION"] = config.aws_region
-    if config.aws_profile or config.aws_region:
-        from opscloud.config.settings import sync_aws_env_aliases
-
-        sync_aws_env_aliases()
-
-    if config.read_only:
-        os.environ["OPSCLOUD_READ_ONLY"] = "true"
-    if config.shell_allow_list:
-        os.environ["OPSCLOUD_SHELL_ALLOW_LIST"] = ",".join(config.shell_allow_list)
-
-    model_spec = config.model or "anthropic:claude-3-5-sonnet-latest"
-    model_res = create_model(model_spec)
-
-    effective_cwd = project_context.user_cwd if project_context else config.cwd
-
-    agent, _composite_backend = create_opscloud_agent(
-        model=model_res.model,
-        assistant_id=config.assistant_id,
-        system_prompt=config.system_prompt,
-        interactive=config.interactive,
-        auto_approve=config.auto_approve,
-        enable_shell=config.enable_shell,
-        cwd=effective_cwd,
-        project_context=project_context,
-    )
-    return agent
-
-
-_precompiled_graph: Any = None
-_graph_lock = asyncio.Lock()
-
-async def make_graph() -> Any:
-    """Return the agent graph for `langgraph dev`.
-
-    Compiles the agent graph lazily on first invocation and caches the CompiledGraph instance
-    to serve subsequent requests in <1ms without per-request compilation latency.
-    """
-    global _precompiled_graph
-    if _precompiled_graph is not None:
-        return _precompiled_graph
-
-    async with _graph_lock:
-        if _precompiled_graph is None:
-            _precompiled_graph = await asyncio.to_thread(_make_graph_sync)
-        return _precompiled_graph