queue-aiops 0.4.0__tar.gz → 0.6.0__tar.gz

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## v0.6.0 — 2026-08-03
+
+### Fixed
+- **A cluster node's key count no longer poses as the whole dataset.** `INFO keyspace` on a Redis Cluster node answers for that node's slots only, so `keyspace` / `overview` reported `totalKeys: 100` for a 3-master cluster actually holding 300 — a dataset-wide claim wrong by the shard count, with nothing in the payload to say otherwise. Both now carry `scope` (`node` vs `server`), `clusterMode`, and on a cluster a note explaining that the figure covers one node. Measured on a real 3-master Redis 7.4 cluster (100 / 92 / 108).
+- **`undo apply` replays against the target the original write ran on.** It dispatched the inverse against whatever target the *caller* named — in practice the config's first entry — while the write's own target sat unused in the undo record. On a multi-target config the inverse therefore ran against the wrong host; it only looks harmless because the resource usually is not there, but two hosts holding the same name and the inverse **succeeds on the wrong one, silently**. An explicitly named target still wins. Line-wide: all 24 copies had the identical defect. Caught live in container-host-aiops, where a stop recorded against a Podman target replayed against a Portainer one.
+
+## v0.5.0 — 2026-08-02
+
+### Changed (BREAKING)
+- **Requires MCP SDK 2.0** (`mcp[cli]>=2.0,<3.0`). `mcp.server.fastmcp` no longer exists in 2.0; the server is now built with `MCPServer` and reports its package version in the stdio handshake.
+
+### Fixed
+- **`undo apply` works from the CLI.** Every write tool is imported lazily inside its own CLI command, so a CLI-driven undo ran in a process where the inverse tool was never registered and failed with "inverse tool is not registered" — for every write tool. Only the MCP entry point, which imports the whole server, worked. Found while live-verifying against a real cluster.
+- **An undetermined outcome is audited `unknown`, not `ok`.** The harness only classified a result as undetermined when the payload *also* carried an `error` key, so a write that looked successful but had not been confirmed was recorded as a success.
+- **`as_int` no longer round-trips integers through float64**, which cannot represent values above 2**53 exactly. A line-wide sweep found only one of six vendored copies had actually been fixed after the original precision bug. The bool guard precedes the int short-circuit because `bool` subclasses `int` — otherwise `True` would be returned unchanged and serialised as `true` rather than a number.
+
+
 ## v0.4.0 — 2026-07-21
 
 ### Changed (BREAKING)

queue_aiops-0.6.0/Dockerfile

@@ -0,0 +1,9 @@
+# syntax=docker/dockerfile:1
+# Minimal image for Glama introspection: starts the MCP server over stdio.
+# The tools/list introspection handshake needs no live Redis/RabbitMQ credentials.
+FROM python:3.12-slim
+
+RUN pip install --no-cache-dir queue-aiops
+
+# MCP server speaks JSON-RPC over stdio.
+ENTRYPOINT ["queue-aiops-mcp"]

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: queue-aiops
-Version: 0.4.0
+Version: 0.6.0
 Summary: Governed AI-ops for redis + rabbitmq: memory-pressure/latency/queue-backlog/connection-churn RCAs, slowlog and SCAN-budgeted big-key sampling, queues/policies/nodes, and governed writes (config set, client kill, purge/delete queue, policies) with a built-in governance harness (audit, budget, undo, risk tiers)
 Author-email: Wei Zhou <zhouwei008@gmail.com>
 License-Expression: MIT
@@ -8,7 +8,7 @@ License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: cryptography>=42.0
 Requires-Dist: httpx<1.0,>=0.27
-Requires-Dist: mcp[cli]<2.0,>=1.10
+Requires-Dist: mcp[cli]<3.0,>=2.0
 Requires-Dist: pyyaml<7.0,>=6.0
 Requires-Dist: redis<7.0,>=5.0
 Requires-Dist: rich<16.0,>=13.0

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/docs/VERIFICATION.md

@@ -29,6 +29,13 @@ plus a regression test that asserts the *type*, keeping genuine ratios
 
 - **RabbitMQ** — the entire `rabbitmq` command group and its management-API
   shapes are unit-tested only. This is now the largest gap in this repo.
-- Redis **cluster / sentinel** topologies (only standalone was exercised).
+- ~~Redis **cluster / sentinel** topologies (only standalone was exercised).~~
+  **Both exercised 2026-08-03**, and the cluster one found a defect: a node's
+  `totalKeys` was reported as the dataset total (100 on a 3-master cluster
+  holding 300). Reads, `overview` and the RCAs otherwise behaved correctly on a
+  cluster node, on a Sentinel-fronted primary, and on its replica (`role:
+  slave`). Still untested: an actual **failover** through Sentinel, and any
+  cluster-wide aggregate — this tool talks to one endpoint by design, which is
+  exactly why the scope marker matters.
 - AUTH-enabled Redis and TLS connections.
 - `kill-client` against a real blocked client.

queue_aiops-0.6.0/glama.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://glama.ai/mcp/schemas/server.json",
+  "maintainers": [
+    "zw008"
+  ]
+}

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/mcp_server/_shared.py

@@ -1,13 +1,15 @@
-"""Shared MCP server primitives: the FastMCP instance, connection helper,
+"""Shared MCP server primitives: the MCPServer instance, connection helper,
 error sanitisation, and the ``@tool_errors`` decorator.
 
 Tool modules under ``mcp_server/tools/`` import ``mcp`` from here and register
 their ``@mcp.tool()`` functions onto it. ``mcp_server/server.py`` then imports
 those modules and runs the server.
 
-Keep ``Optional[X]`` (never PEP 604 ``X | None``) in any FastMCP-reflected
-tool signature — on older mcp/pydantic the union eval'd to ``types.UnionType``
-crashes FastMCP's ``issubclass`` check.
+Keep ``Optional[X]`` (never PEP 604 ``X | None``) in any reflected tool
+signature. mcp>=2.0 accepts the union, but the legacy form is retained for
+consistency and to stay safe under any pydantic reflection path (踩坑 #33 —
+older mcp/pydantic eval'd the union to ``types.UnionType`` and crashed the
+``issubclass`` check).
 """
 
 import functools
@@ -19,8 +21,9 @@ from typing import Any, Optional
 
 import httpx
 import redis
-from mcp.server.fastmcp import FastMCP
+from mcp.server import MCPServer
 
+from queue_aiops import __version__
 from queue_aiops.config import load_config
 from queue_aiops.connection import ConnectionManager, QueueApiError
 from queue_aiops.governance import mark_unknown, sanitize
@@ -78,7 +81,7 @@ def tool_errors(shape: str = "dict") -> Callable:
     """Wrap a tool body in the canonical try/except → ``_safe_error`` pattern.
 
     Place this *between* ``@governed_tool`` and the function so the audit
-    decorator and FastMCP still see the original signature.
+    decorator and MCPServer still see the original signature.
     """
 
     def decorator(func: Callable) -> Callable:
@@ -107,8 +110,9 @@ def tool_errors(shape: str = "dict") -> Callable:
     return decorator
 
 
-mcp = FastMCP(
+mcp = MCPServer(
     "queue-aiops",
+    version=__version__,
     instructions=(
         "Queue/cache broker operations over redis and rabbitmq: for a "
         "redis target — server/memory/keyspace reads, clients, slowlog, config, "

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/mcp_server/tools/undo.py

@@ -22,8 +22,22 @@ from queue_aiops.governance.undo import get_undo_store
 
 
 def _resolve_tool(name: str) -> Any:
-    """Return the governed callable registered under ``name`` (or None)."""
+    """Return the governed callable registered under ``name`` (or None).
+
+    The CLI reaches this through ``undo apply``, whose process only imports
+    ``mcp_server.tools.undo`` — every other tool module is imported lazily inside
+    its own CLI command and so is absent here. Without forcing a full load,
+    ``undo_apply`` would fail with "inverse tool not registered" for every write
+    tool when driven from the CLI (the MCP entry point loads all modules, so it
+    never hit this). If the first lookup misses, import ``mcp_server.server`` —
+    which registers every ``@mcp.tool()`` as an import side effect — and retry.
+    Imported lazily to avoid the undo↔server cycle.
+    """
     tool = mcp._tool_manager._tools.get(name)
+    if tool is None:
+        import mcp_server.server  # noqa: F401 — registers all tools as a side effect
+
+        tool = mcp._tool_manager._tools.get(name)
     return getattr(tool, "fn", None) if tool else None
 
 
@@ -73,6 +87,32 @@ def undo_list(limit: int = 50, target: Optional[str] = None) -> dict:
     }
 
 
+def _origin_target(rec: dict) -> Optional[str]:
+    """The target the ORIGINAL write ran against, read from its recorded params.
+
+    Without this the replay goes to whatever target the caller names — in
+    practice the config's first entry — so on a multi-target config the inverse
+    runs against the wrong host. It only *looks* harmless because the resource
+    usually does not exist there; when two hosts both hold a resource with the
+    same name the inverse succeeds on the wrong one, silently.
+
+    Caught live on 2026-08-03 in container-host-aiops: a ``stop_container``
+    recorded against a Podman target replayed against a Portainer target.
+
+    A ``target`` in ``orig_params`` also means the original call accepted one,
+    so the fallback cannot hand a keyword to a tool that has no such parameter.
+    """
+    raw = rec.get("orig_params") or ""
+    try:
+        orig = json.loads(raw) if raw else {}
+    except (ValueError, TypeError):
+        return None  # unreadable: fall back to the caller/default, as before
+    if not isinstance(orig, dict):
+        return None
+    value = orig.get("target")
+    return value if isinstance(value, str) and value else None
+
+
 @mcp.tool()
 @governed_tool(risk_level="medium")
 @tool_errors("dict")
@@ -136,8 +176,10 @@ def undo_apply(undo_id: str, dry_run: bool = False, target: Optional[str] = None
         }
 
     call_params = dict(params)
-    if target is not None and "target" not in call_params:
-        call_params["target"] = target
+    if "target" not in call_params:
+        chosen = target if target is not None else _origin_target(rec)
+        if chosen is not None:
+            call_params["target"] = chosen
     result = fn(**call_params)
 
     # Only mark applied when the inverse did not itself return an error dict.

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "queue-aiops"
-version = "0.4.0"
+version = "0.6.0"
 description = "Governed AI-ops for redis + rabbitmq: memory-pressure/latency/queue-backlog/connection-churn RCAs, slowlog and SCAN-budgeted big-key sampling, queues/policies/nodes, and governed writes (config set, client kill, purge/delete queue, policies) with a built-in governance harness (audit, budget, undo, risk tiers)"
 readme = "README.md"
 license = "MIT"
@@ -17,7 +17,7 @@ dependencies = [
     "rich>=13.0,<16.0",
     "pyyaml>=6.0,<7.0",
     "cryptography>=42.0",
-    "mcp[cli]>=1.10,<2.0",
+    "mcp[cli]>=2.0,<3.0",
 ]
 
 [dependency-groups]

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/queue_aiops/governance/decorators.py

@@ -382,8 +382,16 @@ def _finalize(state: _CallState) -> None:
     # compliance exception reports are built from this status. 'unknown' is a
     # distinct verdict, not a softer 'error': the request may have taken effect,
     # so the row must not assert a failure the tool cannot actually vouch for.
-    if state.status == "ok" and isinstance(state.result, dict) and state.result.get("error"):
-        state.status = "unknown" if is_unknown(state.result) else "error"
+    if state.status == "ok" and isinstance(state.result, dict):
+        # is_unknown is checked FIRST and independently of ``error``. A write
+        # can be undetermined while looking perfectly successful — a Proxmox
+        # task that has not finished yet returns a normal payload — and gating
+        # this on ``error`` audited those as 'ok', re-creating the very lie the
+        # unknown verdict exists to prevent.
+        if is_unknown(state.result):
+            state.status = "unknown"
+        elif state.result.get("error"):
+            state.status = "error"
 
     duration = int((time.time() - state.start) * 1000)
 

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/queue_aiops/ops/_util.py

@@ -74,6 +74,10 @@ def as_int(value: Any) -> int:
     Non-numeric/absent yields ``0`` to match :func:`num`'s contract for these
     always-present INFO fields.
     """
+    if isinstance(value, bool):  # bool subclasses int; not a quantity
+        return 0
+    if isinstance(value, int):
+        return value  # already exact — never round-trip through float64
     try:
         return int(float(value))
     except (TypeError, ValueError):

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/queue_aiops/ops/overview.py

@@ -54,6 +54,10 @@ def _redis_overview(conn: Any) -> dict:
         "maxmemoryPolicy": mem.get("maxmemoryPolicy"),
         "fragmentationRatio": mem.get("fragmentationRatio"),
         "totalKeys": keys.get("totalKeys"),
+        # On a cluster node totalKeys covers this node's slots only — the scope
+        # marker has to travel with the number, not be left in a sibling call.
+        "keyScope": keys.get("scope"),
+        "clusterMode": keys.get("clusterMode"),
         "errors": errors,
     }
 

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/queue_aiops/ops/redis_reads.py

@@ -190,8 +190,38 @@ def config_get(conn: Any, pattern: str = "*") -> dict:
         return {"error": s(exc, 200)}
 
 
+def _scope(conn: Any) -> dict:
+    """Whether the counts that follow describe the whole dataset or one shard.
+
+    A Redis Cluster node answers ``INFO keyspace`` for **its own slots only**, so
+    on a three-master cluster holding 300 keys this reports 100 — a number that
+    is wrong by the shard count and, called ``totalKeys`` with nothing else in
+    the payload, reads as the whole dataset. Measured on a real 3-master Redis
+    7.4 cluster. The marker travels with the counts so a consumer can tell a
+    complete answer from a partial one.
+    """
+    try:
+        mode = str(as_obj(conn.redis_info("server")).get("redis_mode") or "")
+    except Exception:  # noqa: BLE001 — scope is an annotation, never the answer
+        return {"scope": "server", "clusterMode": None}
+    if mode != "cluster":
+        return {"scope": "server", "clusterMode": False}
+    return {
+        "scope": "node",
+        "clusterMode": True,
+        "note": (
+            "Redis Cluster: these counts cover THIS node's slots only, not the "
+            "whole cluster. Query each master, or use a cluster-aware client, "
+            "for a dataset-wide figure."
+        ),
+    }
+
+
 def keyspace(conn: Any) -> dict:
-    """[READ] Per-db key counts + expiry coverage from INFO keyspace."""
+    """[READ] Per-db key counts + expiry coverage from INFO keyspace.
+
+    On a cluster node the counts are per-shard; the returned ``scope`` says so.
+    """
     try:
         info = as_obj(conn.redis_info("keyspace"))
         dbs = []
@@ -208,7 +238,11 @@ def keyspace(conn: Any) -> dict:
                     "avgTtlMs": as_int(cell.get("avg_ttl")),
                 }
             )
-        return {"databases": dbs, "totalKeys": sum(d["keys"] for d in dbs)}
+        return {
+            "databases": dbs,
+            "totalKeys": sum(d["keys"] for d in dbs),
+            **_scope(conn),
+        }
     except Exception as exc:  # noqa: BLE001 — report as partial
         return {"error": s(exc, 200)}
 

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/AIops-tools/Queue-AIops",
     "source": "github"
   },
-  "version": "0.4.0",
+  "version": "0.6.0",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "queue-aiops",
-      "version": "0.4.0",
+      "version": "0.6.0",
       "transport": {
         "type": "stdio"
       }

queue_aiops-0.6.0/tests/test_int_fidelity.py

@@ -0,0 +1,45 @@
+"""Integer quantities must stay exact integers.
+
+Line-wide invariant, asserted per repo because the helper is vendored per repo.
+It exists because of a live defect in proxy-aiops (Traefik route priority is an
+int64; routing it through the float helper collapsed two *different*
+priorities — …806 and …805 — onto the same displayed value). A 2026-08-02 sweep
+found that only proxy-aiops had actually been fixed: five other ``as_int``
+implementations, this one included, still round-tripped integers through
+float64, which cannot represent values above 2**53 exactly.
+
+The bool case is not pedantry: ``bool`` subclasses ``int``, so an int
+short-circuit placed before a bool guard would return ``True`` unchanged and
+serialise it as ``true`` instead of a number.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from queue_aiops.ops._util import as_int
+
+
+@pytest.mark.unit
+def test_as_int_never_round_trips_an_int_through_float64():
+    hi = 9007199254740993  # 2**53 + 1 — the smallest int a float64 cannot hold
+    lo = 9007199254740992
+    assert as_int(hi) == hi
+    assert as_int(hi) != as_int(lo), "distinct counts must not collapse"
+    # What the float path would have done, kept as the reason this test exists:
+    assert int(float(hi)) == int(float(lo))
+
+
+@pytest.mark.unit
+def test_as_int_returns_a_real_int_not_a_bool():
+    result = as_int(True)
+    assert not isinstance(result, bool), "bool subclasses int; it is not a quantity"
+    assert result == 0
+
+
+@pytest.mark.unit
+def test_as_int_types_and_edges():
+    assert isinstance(as_int("42"), int) and as_int("42") == 42
+    assert as_int(3.9) == 3
+    assert as_int(None) == 0
+    assert as_int("nonsense") == 0

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/tests/test_reads.py

@@ -308,3 +308,36 @@ def test_queue_overview_rabbitmq_shape_degrades_partially():
     assert out["platform"] == "rabbitmq"
     assert out["queues"] == 12
     assert any("nodes:" in e for e in out["errors"])
+
+
+@pytest.mark.unit
+def test_keyspace_marks_a_cluster_node_count_as_partial():
+    """A cluster node's key count is per-shard and must say so.
+
+    ``INFO keyspace`` on a Redis Cluster node answers for its own slots only, so
+    a 3-master cluster holding 300 keys reports 100 here. Emitting that as
+    ``totalKeys`` with nothing else in the payload states a dataset-wide figure
+    that is wrong by the shard count. Measured on a real 3-master Redis 7.4
+    cluster: 100 / 92 / 108.
+    """
+    conn = redis_conn(info={
+        "keyspace": {"db0": "keys=100,expires=0,avg_ttl=0"},
+        "server": {"redis_mode": "cluster"},
+    })
+    out = redis_reads.keyspace(conn)
+    assert out["totalKeys"] == 100
+    assert out["scope"] == "node"
+    assert out["clusterMode"] is True
+    assert "THIS node" in out["note"]
+
+
+@pytest.mark.unit
+def test_keyspace_on_a_standalone_server_is_scoped_whole():
+    conn = redis_conn(info={
+        "keyspace": {"db0": "keys=7,expires=0,avg_ttl=0"},
+        "server": {"redis_mode": "standalone"},
+    })
+    out = redis_reads.keyspace(conn)
+    assert out["scope"] == "server"
+    assert out["clusterMode"] is False
+    assert "note" not in out

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/tests/test_undo_executor.py

@@ -21,18 +21,21 @@ from mcp_server.tools import undo as gov
 from queue_aiops.governance import governed_tool
 
 _CALLS: list[dict] = []
+_TARGETS: list = []
 
 
 @governed_tool(risk_level="low")
 def _undo_probe(value: str = "", target=None) -> dict:
     """Synthetic inverse target used only by the undo-executor tests."""
     _CALLS.append({"value": value})
+    _TARGETS.append(target)
     return {"ok": True, "value": value}
 
 
 @pytest.fixture
 def gov_home(tmp_path, monkeypatch):
     _CALLS.clear()
+    _TARGETS.clear()
     # Register the probe only for the duration of these tests so it never
     # pollutes the real tool registry (which exact-count smoke tests assert on).
     mcp.add_tool(_undo_probe, name="_undo_probe")
@@ -77,6 +80,52 @@ def test_undo_apply_dispatches_inverse_and_marks_applied(gov_home):
     assert uid not in {u["undoId"] for u in gov.undo_list()["undos"]}
 
 
+@pytest.mark.unit
+def test_undo_apply_replays_against_the_target_the_write_ran_on(gov_home):
+    """A replay must go to the host the original write went to.
+
+    Without this the inverse ran against whatever target the caller named — in
+    practice the config's first entry — so on a multi-target config it hit the
+    wrong host. It only looked harmless because the resource usually does not
+    exist there; two hosts holding the same name and the inverse succeeds on the
+    wrong one, silently. Caught live on 2026-08-03 in container-host-aiops: a
+    stop recorded against a Podman target replayed against a Portainer target.
+    """
+    uid = undo_mod.get_undo_store().record(
+        skill="probe",
+        tool="orig_op",
+        undo_descriptor={"tool": "_undo_probe", "params": {"value": "v1"}},
+        orig_params={"value": "v1", "target": "second-host"},
+    )
+    result = gov.undo_apply(undo_id=uid)
+    assert result["applied"] is True
+    assert _TARGETS == ["second-host"]
+
+
+@pytest.mark.unit
+def test_undo_apply_prefers_an_explicit_caller_target(gov_home):
+    """An explicitly named target still wins — the fallback is only a default."""
+    uid = undo_mod.get_undo_store().record(
+        skill="probe",
+        tool="orig_op",
+        undo_descriptor={"tool": "_undo_probe", "params": {"value": "v1"}},
+        orig_params={"value": "v1", "target": "second-host"},
+    )
+    gov.undo_apply(undo_id=uid, target="chosen-host")
+    assert _TARGETS == ["chosen-host"]
+
+
+@pytest.mark.unit
+def test_undo_apply_survives_unreadable_orig_params(gov_home):
+    """Corrupt orig_params must not break the replay — just lose the fallback."""
+    uid = _record(params={"value": "v1"})
+    with sqlite3.connect(gov_home / "undo.db") as db:
+        db.execute("UPDATE undo_log SET orig_params = ? WHERE undo_id = ?",
+                   ("{not json", uid))
+    assert gov.undo_apply(undo_id=uid)["applied"] is True
+    assert _TARGETS == [None]
+
+
 @pytest.mark.unit
 def test_undo_apply_dry_run_previews_without_running(gov_home):
     uid = _record()
@@ -157,3 +206,40 @@ def test_undo_apply_audits_both_wrapper_and_inverse(gov_home):
         conn.close()
     assert "undo_apply" in tools
     assert "_undo_probe" in tools
+
+
+@pytest.mark.unit
+def test_resolve_tool_loads_full_registry_under_cli_only_import():
+    """Regression (live-found 2026-07-31): CLI ``undo apply`` runs in a process
+    that imports only ``mcp_server.tools.undo`` — every write tool is imported
+    lazily inside its own CLI command, so the inverse was "not registered" and
+    CLI-initiated undo failed for every write tool. ``_resolve_tool`` must force
+    a full server load on a miss.
+
+    Reproduced in a FRESH interpreter, because this pytest process has already
+    imported the whole server, which would mask the bug.
+    """
+    import subprocess
+    import sys
+    import textwrap
+
+    script = textwrap.dedent(
+        """
+        from mcp_server._shared import mcp
+        import mcp_server.tools.undo as u
+        before = set(mcp._tool_manager._tools)
+        # A miss must trigger the full-registry load, not just return None.
+        u._resolve_tool("__definitely_not_a_tool__")
+        after = set(mcp._tool_manager._tools)
+        new = after - before
+        assert new, "fallback loaded no additional tools"
+        sample = sorted(new)[0]
+        assert u._resolve_tool(sample) is not None, sample
+        print("OK", len(before), len(after))
+        """
+    )
+    r = subprocess.run(
+        [sys.executable, "-c", script], capture_output=True, text=True
+    )
+    assert r.returncode == 0, r.stderr
+    assert r.stdout.startswith("OK"), r.stdout

{queue_aiops-0.4.0 → queue_aiops-0.6.0}/uv.lock

@@ -352,6 +352,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
 ]
 
+[[package]]
+name = "httpcore2"
+version = "2.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "h11" },
+    { name = "truststore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/39/a8/20ed1ed79cbc2ecdf5301c0968ab7c85547212e2a7bd126ddd2d986e206e/httpcore2-2.9.1.tar.gz", hash = "sha256:4d8acbf8b306f48c9d6046591fd5ba4037d1b1b1000d140fc2c3eab1e9a0c0e2", size = 67089, upload-time = "2026-07-24T09:21:03.867Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/fb/46c52b781975c335a2bcf1072c7bbc007cbdc8d674217f5ee1daba2c848b/httpcore2-2.9.1-py3-none-any.whl", hash = "sha256:6182472379e855fe4221246a2bb7ecede403bc61c6798062ae1787d051ccde26", size = 82809, upload-time = "2026-07-24T09:21:01.178Z" },
+]
+
 [[package]]
 name = "httpx"
 version = "0.28.1"
@@ -368,12 +381,19 @@ wheels = [
 ]
 
 [[package]]
-name = "httpx-sse"
-version = "0.4.3"
+name = "httpx2"
+version = "2.9.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
+dependencies = [
+    { name = "anyio" },
+    { name = "httpcore2" },
+    { name = "idna" },
+    { name = "truststore" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/21/14/38128fbafd7e0ed41d874df6c9a653d47c2d111cfe59e2b4ac95161b4abd/httpx2-2.9.1.tar.gz", hash = "sha256:1932a768737e3666291582833da748cc4e563c337cf96706fccc04fa6e58764a", size = 95458, upload-time = "2026-07-24T09:21:04.972Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
+    { url = "https://files.pythonhosted.org/packages/13/b8/cfd91c4ab9134d386d48f0b6ac662ff3d4be6efdee59ee1c67ebc3c0487c/httpx2-2.9.1-py3-none-any.whl", hash = "sha256:1820fe14a9ab1107bfeff39259987429450b070ec0ff38cc87eb0d8c97fdc71a", size = 91191, upload-time = "2026-07-24T09:21:02.6Z" },
 ]
 
 [[package]]
@@ -435,15 +455,15 @@ wheels = [
 
 [[package]]
 name = "mcp"
-version = "1.28.1"
+version = "2.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
-    { name = "httpx" },
-    { name = "httpx-sse" },
+    { name = "httpx2" },
     { name = "jsonschema" },
+    { name = "mcp-types" },
+    { name = "opentelemetry-api" },
     { name = "pydantic" },
-    { name = "pydantic-settings" },
     { name = "pyjwt", extra = ["crypto"] },
     { name = "python-multipart" },
     { name = "pywin32", marker = "sys_platform == 'win32'" },
@@ -453,9 +473,9 @@ dependencies = [
     { name = "typing-inspection" },
     { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6e/77/9450b8f251a13affb6281997d0523c4615f8a8b35d0b21ff30db3a5aac9d/mcp-1.28.1.tar.gz", hash = "sha256:d51e36a5f5644faea4f85ea649bfffa6bc6c26770d42798ad6a3de3d2ba69683", size = 638501, upload-time = "2026-06-26T12:57:29.093Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/33/32d4dff2c95bb5d897c3ef4c83649a08996b17b58f0a326d2495d4c81179/mcp-2.0.0.tar.gz", hash = "sha256:0f440e735c13ece8bb19bc62cf0b86f4313448432fbb77d35e14034f4e050728", size = 1662284, upload-time = "2026-07-28T13:45:32.346Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e2/5e/d118fce19f87a2e7d8101c35c8ae0ec289098a4df0ff244cec23e415aca0/mcp-1.28.1-py3-none-any.whl", hash = "sha256:2726bca5e7193f61c5dde8b12500a6de2d9acf6d1a1c0be9e8c2e706437991df", size = 222620, upload-time = "2026-06-26T12:57:27.218Z" },
+    { url = "https://files.pythonhosted.org/packages/67/72/7d7897418912c1d12e87556630dfb7bf0eac71160e9bef8b447960804ee3/mcp-2.0.0-py3-none-any.whl", hash = "sha256:1cb4c75d2d2c7b8c1d756355e5d82a39f2822cc7f13e22a2051d7ca3592349d6", size = 349980, upload-time = "2026-07-28T13:45:28.853Z" },
 ]
 
 [package.optional-dependencies]
@@ -464,6 +484,19 @@ cli = [
     { name = "typer" },
 ]
 
+[[package]]
+name = "mcp-types"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/56/9b8e1c152f61f6c6b07c4b5896c88c7d0ae90bac6ee6306f852fcc5c1eb0/mcp_types-2.0.0.tar.gz", hash = "sha256:d7d939b9285c9961ae8866ba75ef85da34d12bafe276efbf4eb6a131786d8379", size = 66632, upload-time = "2026-07-28T13:45:33.804Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f5/4c/c78d78c3d52b0ac594ad7cc8ef5972adfe070e3597a8a4c6ce0cd39196ea/mcp_types-2.0.0-py3-none-any.whl", hash = "sha256:6b2de797ca2797f568b79529e1b25948e34de511bcc0bd82fef1039a6d1b8eb0", size = 69649, upload-time = "2026-07-28T13:45:30.713Z" },
+]
+
 [[package]]
 name = "mdurl"
 version = "0.1.2"
@@ -473,6 +506,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
 ]
 
+[[package]]
+name = "opentelemetry-api"
+version = "1.44.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ee/8b/aa9e2d8b8dfa7c946f7dec5d1f8f6ba8eca062f43509a06bdb5ce93d26c0/opentelemetry_api-1.44.0.tar.gz", hash = "sha256:67647e5e9566edcf421166fdf022b3537f818635daa852b289e34604dc6fb33a", size = 72406, upload-time = "2026-07-16T15:25:32.678Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ca/6f/a04e900f465ff3221ccc395522503e2d10e79fa21f2723c8e177aae1e0d1/opentelemetry_api-1.44.0-py3-none-any.whl", hash = "sha256:94b98c893a91b88657eaac1e3ba89618cdb85be6918196705354f34728b2cdef", size = 60018, upload-time = "2026-07-16T15:25:11.657Z" },
+]
+
 [[package]]
 name = "packaging"
 version = "26.2"
@@ -617,20 +662,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4b/2d/69abac8f838090bbecd5df894befb2c2619e7996a98ddb949db9f3b93225/pydantic_core-2.46.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:d51026d73fcfd93610abc7b27789c26b313920fcfb20e27462d74a7f8b06e983", size = 2193071, upload-time = "2026-05-06T13:38:08.682Z" },
 ]
 
-[[package]]
-name = "pydantic-settings"
-version = "2.14.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5c/b5/8f48e906c3e0205276e8bd8cb7512217a87b2685304d64be27cad5b3019f/pydantic_settings-2.14.2.tar.gz", hash = "sha256:c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f", size = 237700, upload-time = "2026-06-19T13:44:56.324Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/c1/6e422f34e569cf8e18df68d1939c81c099d2b61e4f7d9621c8a77560799c/pydantic_settings-2.14.2-py3-none-any.whl", hash = "sha256:a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440", size = 61715, upload-time = "2026-06-19T13:44:55.02Z" },
-]
-
 [[package]]
 name = "pygments"
 version = "2.20.0"
@@ -781,7 +812,7 @@ wheels = [
 
 [[package]]
 name = "queue-aiops"
-version = "0.4.0"
+version = "0.6.0"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },
@@ -804,7 +835,7 @@ dev = [
 requires-dist = [
     { name = "cryptography", specifier = ">=42.0" },
     { name = "httpx", specifier = ">=0.27,<1.0" },
-    { name = "mcp", extras = ["cli"], specifier = ">=1.10,<2.0" },
+    { name = "mcp", extras = ["cli"], specifier = ">=2.0,<3.0" },
     { name = "pyyaml", specifier = ">=6.0,<7.0" },
     { name = "redis", specifier = ">=5.0,<7.0" },
     { name = "rich", specifier = ">=13.0,<16.0" },
@@ -1094,6 +1125,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
 ]
 
+[[package]]
+name = "truststore"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" },
+]
+
 [[package]]
 name = "typer"
 version = "0.27.0"