gitlab-api 25.43.0__tar.gz → 25.46.0__tar.gz

{gitlab_api-25.43.0 → gitlab_api-25.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitlab-api
-Version: 25.43.0
+Version: 25.46.0
 Summary: GitLab API + MCP Server + A2A Server
 Author-email: Audel Rouhi <knucklessg1@gmail.com>
 License: MIT
@@ -12,17 +12,17 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: <3.15,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: agent-utilities>=0.48.0
+Requires-Dist: agent-utilities>=0.51.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: gql[requests]>=4.0.0
 Provides-Extra: mcp
-Requires-Dist: agent-utilities[mcp]>=0.48.0; extra == "mcp"
+Requires-Dist: agent-utilities[mcp]>=0.51.0; extra == "mcp"
 Provides-Extra: agent
-Requires-Dist: agent-utilities[agent,logfire]>=0.48.0; extra == "agent"
+Requires-Dist: agent-utilities[agent,logfire]>=0.51.0; extra == "agent"
 Provides-Extra: gql
 Requires-Dist: gql[requests]>=4.0.0; extra == "gql"
 Provides-Extra: all
-Requires-Dist: gitlab-api[agent,gql,logfire,mcp]>=25.43.0; extra == "all"
+Requires-Dist: gitlab-api[agent,gql,logfire,mcp]>=25.46.0; extra == "all"
 Provides-Extra: test
 Requires-Dist: pytest-xdist>=3.6.0; extra == "test"
 Requires-Dist: pytest; extra == "test"
@@ -52,7 +52,7 @@ Dynamic: license-file
 ![PyPI - Wheel](https://img.shields.io/pypi/wheel/gitlab-api)
 ![PyPI - Implementation](https://img.shields.io/pypi/implementation/gitlab-api)
 
-*Version: 25.43.0*
+*Version: 25.46.0*
 
 > **Documentation** — Installation, deployment, usage across the API, CLI, and MCP
 > interfaces, the integrated A2A agent server, and guidance for provisioning the
@@ -320,6 +320,39 @@ Detailed graph node architecture explanations, custom skill configurations, and
 
 ---
 
+## Multi-Tenancy (multiple GitLab instances)
+
+The client is natively multi-tenant. The set of instances is declared once in the
+shared **agent-utilities XDG config** (`~/.config/agent-utilities/config.json`) under
+`gitlab_instances` — the **same** list the Knowledge-Graph GitLab indexer reads, so one
+config drives both code/metadata indexing and every API/MCP call:
+
+```json
+{
+  "gitlab_instances": [
+    {"name": "internal", "url": "https://gitlab.arpa", "token": "glpat-xxxx", "verify_ssl": false},
+    {"name": "public",   "url": "https://gitlab.com",  "token": "glpat-yyyy", "verify_ssl": true}
+  ]
+}
+```
+
+Target a tenant by **name** from the client factory; a bare URL still works, and an
+unset instance resolves to the first configured one (else `GITLAB_URL`/`GITLAB_TOKEN`):
+
+```python
+from gitlab_api.auth import get_client
+from gitlab_api.instances import list_configured_instances
+
+internal = get_client(instance="internal")   # resolves url+token+verify from config
+public   = get_client(instance="public")
+default  = get_client()                        # first configured / GITLAB_URL fallback
+names    = [i.name for i in list_configured_instances()]
+```
+
+The MCP server exposes a `gitlab_instances` tool (`action=list|get`) to discover the
+configured tenants (tokens are never returned). When no instances are configured, the
+connector falls back to the single-host `GITLAB_URL`/`GITLAB_TOKEN` it has always used.
+
 ## Security & Governance
 
 Built directly upon the enterprise-ready [`agent-utilities`](https://github.com/Knuckles-Team/agent-utilities) core, standard security parameters are fully supported:

gitlab_api-25.43.0/gitlab_api.egg-info/PKG-INFO → gitlab_api-25.46.0/README.md

@@ -1,35 +1,3 @@
-Metadata-Version: 2.4
-Name: gitlab-api
-Version: 25.43.0
-Summary: GitLab API + MCP Server + A2A Server
-Author-email: Audel Rouhi <knucklessg1@gmail.com>
-License: MIT
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Environment :: Console
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Requires-Python: <3.15,>=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: agent-utilities>=0.48.0
-Requires-Dist: python-dotenv>=1.0.0
-Requires-Dist: gql[requests]>=4.0.0
-Provides-Extra: mcp
-Requires-Dist: agent-utilities[mcp]>=0.48.0; extra == "mcp"
-Provides-Extra: agent
-Requires-Dist: agent-utilities[agent,logfire]>=0.48.0; extra == "agent"
-Provides-Extra: gql
-Requires-Dist: gql[requests]>=4.0.0; extra == "gql"
-Provides-Extra: all
-Requires-Dist: gitlab-api[agent,gql,logfire,mcp]>=25.43.0; extra == "all"
-Provides-Extra: test
-Requires-Dist: pytest-xdist>=3.6.0; extra == "test"
-Requires-Dist: pytest; extra == "test"
-Requires-Dist: pytest-asyncio; extra == "test"
-Requires-Dist: pytest-cov; extra == "test"
-Dynamic: license-file
-
 # Gitlab Api
 ## CLI or API | MCP | Agent
 
@@ -52,7 +20,7 @@ Dynamic: license-file
 ![PyPI - Wheel](https://img.shields.io/pypi/wheel/gitlab-api)
 ![PyPI - Implementation](https://img.shields.io/pypi/implementation/gitlab-api)
 
-*Version: 25.43.0*
+*Version: 25.46.0*
 
 > **Documentation** — Installation, deployment, usage across the API, CLI, and MCP
 > interfaces, the integrated A2A agent server, and guidance for provisioning the
@@ -320,6 +288,39 @@ Detailed graph node architecture explanations, custom skill configurations, and
 
 ---
 
+## Multi-Tenancy (multiple GitLab instances)
+
+The client is natively multi-tenant. The set of instances is declared once in the
+shared **agent-utilities XDG config** (`~/.config/agent-utilities/config.json`) under
+`gitlab_instances` — the **same** list the Knowledge-Graph GitLab indexer reads, so one
+config drives both code/metadata indexing and every API/MCP call:
+
+```json
+{
+  "gitlab_instances": [
+    {"name": "internal", "url": "https://gitlab.arpa", "token": "glpat-xxxx", "verify_ssl": false},
+    {"name": "public",   "url": "https://gitlab.com",  "token": "glpat-yyyy", "verify_ssl": true}
+  ]
+}
+```
+
+Target a tenant by **name** from the client factory; a bare URL still works, and an
+unset instance resolves to the first configured one (else `GITLAB_URL`/`GITLAB_TOKEN`):
+
+```python
+from gitlab_api.auth import get_client
+from gitlab_api.instances import list_configured_instances
+
+internal = get_client(instance="internal")   # resolves url+token+verify from config
+public   = get_client(instance="public")
+default  = get_client()                        # first configured / GITLAB_URL fallback
+names    = [i.name for i in list_configured_instances()]
+```
+
+The MCP server exposes a `gitlab_instances` tool (`action=list|get`) to discover the
+configured tenants (tokens are never returned). When no instances are configured, the
+connector falls back to the single-host `GITLAB_URL`/`GITLAB_TOKEN` it has always used.
+
 ## Security & Governance
 
 Built directly upon the enterprise-ready [`agent-utilities`](https://github.com/Knuckles-Team/agent-utilities) core, standard security parameters are fully supported:

{gitlab_api-25.43.0 → gitlab_api-25.46.0}/gitlab_api/__init__.py

@@ -37,7 +37,7 @@ for module_name in CORE_MODULES:
         _expose_members(module)
 
 # Dynamic/lazy loading of optional modules (agent_server, mcp_server)
-_loaded_optional_modules = {}
+_loaded_optional_modules: dict[str, Any] = {}
 
 
 def _import_module_safely(module_name: str):

{gitlab_api-25.43.0 → gitlab_api-25.46.0}/gitlab_api/agent_server.py

@@ -4,7 +4,7 @@ import os
 import sys
 import warnings
 
-__version__ = "25.43.0"
+__version__ = "25.46.0"
 
 logging.basicConfig(
     level=logging.INFO,

{gitlab_api-25.43.0 → gitlab_api-25.46.0}/gitlab_api/auth.py

@@ -22,17 +22,62 @@ from gitlab_api.api_client import Api
 logger = get_logger(__name__)
 
 
+def _resolve_connection(
+    instance: str | None, token: str | None, verify: bool | None
+) -> tuple[str, str | None, bool]:
+    """Resolve ``(url, token, verify)`` for a target tenant (CONCEPT:KG-2.9g).
+
+    ``instance`` may be a configured instance NAME (resolved from the shared
+    ``gitlab_instances`` config), a bare URL (used as-is, back-compat), or ``None``
+    (the default instance, else ``GITLAB_URL``). Explicit ``token``/``verify`` args
+    always win over the instance's stored values.
+    """
+    from gitlab_api.instances import get_instance
+
+    env_verify = to_boolean(string=os.getenv("GITLAB_SSL_VERIFY", "True"))
+
+    # A bare URL is used directly (the historical call shape) — the caller owns
+    # the token it passes (no env fallback, so an explicit token=None stays None).
+    if instance and str(instance).startswith(("http://", "https://")):
+        return (instance, token, env_verify if verify is None else verify)
+
+    # A name (or None=default) resolves against the configured tenants.
+    inst = get_instance(instance)
+    if inst is None:
+        if instance:
+            raise RuntimeError(
+                f"GitLab instance '{instance}' is not configured. Add it to "
+                "gitlab_instances in ~/.config/agent-utilities/config.json, or pass "
+                "a full URL / set GITLAB_URL+GITLAB_TOKEN."
+            )
+        # No config at all → legacy single-host env defaults.
+        return (
+            os.getenv("GITLAB_URL", "https://gitlab.com"),
+            token or os.getenv("GITLAB_TOKEN"),
+            env_verify if verify is None else verify,
+        )
+    return (
+        inst.url,
+        token or inst.token or os.getenv("GITLAB_TOKEN"),
+        inst.verify_ssl if verify is None else verify,
+    )
+
+
 def get_client(
-    instance: str = os.getenv("GITLAB_URL", "https://gitlab.com"),
-    token: str | None = os.getenv("GITLAB_TOKEN", None),
-    verify: bool = to_boolean(string=os.getenv("GITLAB_SSL_VERIFY", "True")),
+    instance: str | None = None,
+    token: str | None = None,
+    verify: bool | None = None,
     config: dict | None = None,
 ) -> Api:
     """Factory function to create the GitLab Api client.
 
-    Supports OIDC delegation and fixed credentials (token).
-    Uses the shared ``delegated_auth`` helper from agent-utilities.
+    Multi-tenant (CONCEPT:KG-2.9g): ``instance`` selects a configured tenant by
+    name (from the shared ``gitlab_instances`` config), accepts a bare URL, or
+    defaults to the first configured instance / ``GITLAB_URL``. Supports OIDC
+    delegation and fixed credentials (token) via the shared ``delegated_auth``
+    helper from agent-utilities.
     """
+    instance, token, verify = _resolve_connection(instance, token, verify)
     from agent_utilities.mcp.delegated_auth import (
         get_delegated_token,
         get_user_identity,
@@ -80,15 +125,18 @@ def get_client(
 
 
 def get_graphql_client(
-    instance: str = os.getenv("GITLAB_URL", "https://gitlab.com"),
-    token: str | None = os.getenv("GITLAB_TOKEN", None),
-    verify: bool = to_boolean(string=os.getenv("GITLAB_SSL_VERIFY", "True")),
+    instance: str | None = None,
+    token: str | None = None,
+    verify: bool | None = None,
     config: dict | None = None,
 ) -> Any:
     """Factory function to create the GitLab GraphQL client.
 
-    Supports OIDC delegation and fixed credentials (token).
+    Multi-tenant (CONCEPT:KG-2.9g): ``instance`` selects a configured tenant by
+    name, a bare URL, or the default. Supports OIDC delegation and fixed
+    credentials (token).
     """
+    instance, token, verify = _resolve_connection(instance, token, verify)
     from agent_utilities.mcp.delegated_auth import (
         get_delegated_token,
         get_user_identity,

gitlab_api-25.46.0/gitlab_api/instances.py

@@ -0,0 +1,110 @@
+"""Multi-tenant GitLab instance registry.
+
+The single source of truth for *which* GitLab instances exist is the
+agent-utilities XDG config (`~/.config/agent-utilities/config.json`,
+`gitlab_instances`) — the same list the KG GitLab indexer reads — so one config
+drives both code/metadata indexing AND every `gitlab-api` client/MCP call. When
+no instances are configured it falls back to the single-host `GITLAB_URL` /
+`GITLAB_TOKEN` env the connector has always used.
+
+`get_client(instance="<name>")` (auth.py) resolves a configured instance by
+name; a bare URL still works (back-compat), and an unset instance resolves to
+the default (first configured, else `GITLAB_URL`).
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from urllib.parse import urlparse
+
+from agent_utilities.base_utilities import get_logger, to_boolean
+
+logger = get_logger(__name__)
+
+
+@dataclass(frozen=True)
+class GitLabInstance:
+    """Connection facts for one GitLab tenant."""
+
+    name: str
+    url: str
+    token: str = ""
+    verify_ssl: bool = True
+
+
+def _host_slug(url: str) -> str:
+    return (urlparse(url).netloc or url).lower()
+
+
+def _from_shared_config() -> list[GitLabInstance]:
+    """Read the structured `gitlab_instances` list from the agent-utilities config."""
+    try:
+        from agent_utilities.core.config import config
+
+        raw = getattr(config, "gitlab_instances", None) or []
+    except Exception:  # noqa: BLE001 - config optional; fall back to env
+        return []
+    out: list[GitLabInstance] = []
+    for item in raw:
+        if not isinstance(item, dict):
+            continue
+        url = str(item.get("url", "")).strip()
+        if not url:
+            continue
+        out.append(
+            GitLabInstance(
+                name=str(item.get("name") or _host_slug(url)),
+                url=url,
+                token=str(item.get("token", "")),
+                verify_ssl=bool(item.get("verify_ssl", True)),
+            )
+        )
+    return out
+
+
+def _single_host_fallback() -> list[GitLabInstance]:
+    """The legacy single-host instance from GITLAB_URL / GITLAB_TOKEN, if a token is set."""
+    url = os.getenv("GITLAB_URL", "https://gitlab.com")
+    token = os.getenv("GITLAB_TOKEN")
+    if not token:
+        return []
+    return [
+        GitLabInstance(
+            name=_host_slug(url),
+            url=url,
+            token=token,
+            verify_ssl=to_boolean(string=os.getenv("GITLAB_SSL_VERIFY", "True")),
+        )
+    ]
+
+
+def list_configured_instances() -> list[GitLabInstance]:
+    """Every configured GitLab instance (shared config first, else single-host env)."""
+    return _from_shared_config() or _single_host_fallback()
+
+
+def get_instance(name: str | None = None) -> GitLabInstance | None:
+    """Resolve one instance by name, or the default (first configured) when ``name`` is None."""
+    instances = list_configured_instances()
+    if not instances:
+        return None
+    if name is None:
+        return instances[0]
+    for inst in instances:
+        if inst.name == name:
+            return inst
+    return None
+
+
+def instance_summaries() -> list[dict[str, object]]:
+    """Tenant list for discovery — names/urls/verify only, NEVER tokens."""
+    return [
+        {
+            "name": i.name,
+            "url": i.url,
+            "verify_ssl": i.verify_ssl,
+            "has_token": bool(i.token),
+        }
+        for i in list_configured_instances()
+    ]

{gitlab_api-25.43.0 → gitlab_api-25.46.0}/gitlab_api/mcp/mcp_branches.py

@@ -5,6 +5,7 @@ Auto-generated from mcp_server.py during ecosystem standardization.
 
 from typing import Any
 
+from agent_utilities.mcp_utilities import resolve_action, run_blocking
 from fastmcp import Context, FastMCP
 from fastmcp.dependencies import Depends
 from pydantic import Field
@@ -38,12 +39,19 @@ def register_branches_tools(mcp: FastMCP):
 
         kwargs = {k: v for k, v in kwargs.items() if v is not None}
 
+        resolved = resolve_action(
+            action, {"get", "create", "delete"}, service="gitlab-api"
+        )
+        if isinstance(resolved, dict):
+            return resolved
+        action = resolved
+
         if action == "get":
             if "branch" in kwargs:
-                return client.get_branch(**kwargs)
-            return client.get_branches(**kwargs)
+                return await run_blocking(client.get_branch, **kwargs)
+            return await run_blocking(client.get_branches, **kwargs)
         if action == "create":
-            return client.create_branch(**kwargs)
+            return await run_blocking(client.create_branch, **kwargs)
         if action == "delete":
-            return client.delete_branch(**kwargs)
+            return await run_blocking(client.delete_branch, **kwargs)
         raise ValueError(f"Unknown action: {action}")

{gitlab_api-25.43.0 → gitlab_api-25.46.0}/gitlab_api/mcp/mcp_commits.py

@@ -5,6 +5,7 @@ Auto-generated from mcp_server.py during ecosystem standardization.
 
 from typing import Any
 
+from agent_utilities.mcp_utilities import resolve_action, run_blocking
 from fastmcp import Context, FastMCP
 from fastmcp.dependencies import Depends
 from pydantic import Field
@@ -38,28 +39,49 @@ def register_commits_tools(mcp: FastMCP):
 
         kwargs = {k: v for k, v in kwargs.items() if v is not None}
 
+        resolved = resolve_action(
+            action,
+            {
+                "get",
+                "create",
+                "diff",
+                "revert",
+                "get_comments",
+                "create_comment",
+                "get_discussions",
+                "get_statuses",
+                "post_status",
+                "get_merge_requests",
+                "get_gpg_signature",
+            },
+            service="gitlab-api",
+        )
+        if isinstance(resolved, dict):
+            return resolved
+        action = resolved
+
         if action == "get":
             if "commit_sha" in kwargs:
-                return client.get_commit(**kwargs)
-            return client.get_commits(**kwargs)
+                return await run_blocking(client.get_commit, **kwargs)
+            return await run_blocking(client.get_commits, **kwargs)
         if action == "create":
-            return client.create_commit(**kwargs)
+            return await run_blocking(client.create_commit, **kwargs)
         if action == "diff":
-            return client.get_commit_diff(**kwargs)
+            return await run_blocking(client.get_commit_diff, **kwargs)
         if action == "revert":
-            return client.revert_commit(**kwargs)
+            return await run_blocking(client.revert_commit, **kwargs)
         if action == "get_comments":
-            return client.get_commit_comments(**kwargs)
+            return await run_blocking(client.get_commit_comments, **kwargs)
         if action == "create_comment":
-            return client.create_commit_comment(**kwargs)
+            return await run_blocking(client.create_commit_comment, **kwargs)
         if action == "get_discussions":
-            return client.get_commit_discussions(**kwargs)
+            return await run_blocking(client.get_commit_discussions, **kwargs)
         if action == "get_statuses":
-            return client.get_commit_statuses(**kwargs)
+            return await run_blocking(client.get_commit_statuses, **kwargs)
         if action == "post_status":
-            return client.post_build_status_to_commit(**kwargs)
+            return await run_blocking(client.post_build_status_to_commit, **kwargs)
         if action == "get_merge_requests":
-            return client.get_commit_merge_requests(**kwargs)
+            return await run_blocking(client.get_commit_merge_requests, **kwargs)
         if action == "get_gpg_signature":
-            return client.get_commit_gpg_signature(**kwargs)
+            return await run_blocking(client.get_commit_gpg_signature, **kwargs)
         raise ValueError(f"Unknown action: {action}")

{gitlab_api-25.43.0 → gitlab_api-25.46.0}/gitlab_api/mcp/mcp_custom_api.py

@@ -5,6 +5,7 @@ Auto-generated from mcp_server.py during ecosystem standardization.
 
 from typing import Any
 
+from agent_utilities.mcp_utilities import run_blocking
 from fastmcp import Context, FastMCP
 from fastmcp.dependencies import Depends
 from pydantic import Field
@@ -41,4 +42,6 @@ def register_custom_api_tools(mcp: FastMCP):
             return {"error": f"Invalid params_json: {e}"}
 
         kwargs = {k: v for k, v in kwargs.items() if v is not None}
-        return client.api_request(method=method, endpoint=endpoint, **kwargs)
+        return await run_blocking(
+            client.api_request, method=method, endpoint=endpoint, **kwargs
+        )

{gitlab_api-25.43.0 → gitlab_api-25.46.0}/gitlab_api/mcp/mcp_deploy_tokens.py

@@ -5,6 +5,7 @@ Auto-generated from mcp_server.py during ecosystem standardization.
 
 from typing import Any
 
+from agent_utilities.mcp_utilities import resolve_action, run_blocking
 from fastmcp import Context, FastMCP
 from fastmcp.dependencies import Depends
 from pydantic import Field
@@ -38,22 +39,39 @@ def register_deploy_tokens_tools(mcp: FastMCP):
 
         kwargs = {k: v for k, v in kwargs.items() if v is not None}
 
+        resolved = resolve_action(
+            action,
+            {
+                "get",
+                "get_project",
+                "create_project",
+                "delete_project",
+                "get_group",
+                "create_group",
+                "delete_group",
+            },
+            service="gitlab-api",
+        )
+        if isinstance(resolved, dict):
+            return resolved
+        action = resolved
+
         if action == "get":
             if "token_id" in kwargs and "project_id" in kwargs:
-                return client.get_project_deploy_token(**kwargs)
+                return await run_blocking(client.get_project_deploy_token, **kwargs)
             elif "token_id" in kwargs and "group_id" in kwargs:
-                return client.get_group_deploy_token(**kwargs)
-            return client.get_deploy_tokens(**kwargs)
+                return await run_blocking(client.get_group_deploy_token, **kwargs)
+            return await run_blocking(client.get_deploy_tokens, **kwargs)
         if action == "get_project":
-            return client.get_project_deploy_tokens(**kwargs)
+            return await run_blocking(client.get_project_deploy_tokens, **kwargs)
         if action == "create_project":
-            return client.create_project_deploy_token(**kwargs)
+            return await run_blocking(client.create_project_deploy_token, **kwargs)
         if action == "delete_project":
-            return client.delete_project_deploy_token(**kwargs)
+            return await run_blocking(client.delete_project_deploy_token, **kwargs)
         if action == "get_group":
-            return client.get_group_deploy_tokens(**kwargs)
+            return await run_blocking(client.get_group_deploy_tokens, **kwargs)
         if action == "create_group":
-            return client.create_group_deploy_token(**kwargs)
+            return await run_blocking(client.create_group_deploy_token, **kwargs)
         if action == "delete_group":
-            return client.delete_group_deploy_token(**kwargs)
+            return await run_blocking(client.delete_group_deploy_token, **kwargs)
         raise ValueError(f"Unknown action: {action}")

{gitlab_api-25.43.0 → gitlab_api-25.46.0}/gitlab_api/mcp/mcp_environments.py

@@ -5,6 +5,7 @@ Auto-generated from mcp_server.py during ecosystem standardization.
 
 from typing import Any
 
+from agent_utilities.mcp_utilities import resolve_action, run_blocking
 from fastmcp import Context, FastMCP
 from fastmcp.dependencies import Depends
 from pydantic import Field
@@ -38,30 +39,51 @@ def register_environments_tools(mcp: FastMCP):
 
         kwargs = {k: v for k, v in kwargs.items() if v is not None}
 
+        resolved = resolve_action(
+            action,
+            {
+                "get",
+                "create",
+                "update",
+                "delete",
+                "stop",
+                "stop_stale",
+                "delete_stopped",
+                "get_protected",
+                "protect",
+                "update_protected",
+                "unprotect",
+            },
+            service="gitlab-api",
+        )
+        if isinstance(resolved, dict):
+            return resolved
+        action = resolved
+
         if action == "get":
             if "environment_id" in kwargs:
-                return client.get_environment(**kwargs)
-            return client.get_environments(**kwargs)
+                return await run_blocking(client.get_environment, **kwargs)
+            return await run_blocking(client.get_environments, **kwargs)
         if action == "create":
-            return client.create_environment(**kwargs)
+            return await run_blocking(client.create_environment, **kwargs)
         if action == "update":
-            return client.update_environment(**kwargs)
+            return await run_blocking(client.update_environment, **kwargs)
         if action == "delete":
-            return client.delete_environment(**kwargs)
+            return await run_blocking(client.delete_environment, **kwargs)
         if action == "stop":
-            return client.stop_environment(**kwargs)
+            return await run_blocking(client.stop_environment, **kwargs)
         if action == "stop_stale":
-            return client.stop_stale_environments(**kwargs)
+            return await run_blocking(client.stop_stale_environments, **kwargs)
         if action == "delete_stopped":
-            return client.delete_stopped_environments(**kwargs)
+            return await run_blocking(client.delete_stopped_environments, **kwargs)
         if action == "get_protected":
             if "environment_name" in kwargs:
-                return client.get_protected_environment(**kwargs)
-            return client.get_protected_environments(**kwargs)
+                return await run_blocking(client.get_protected_environment, **kwargs)
+            return await run_blocking(client.get_protected_environments, **kwargs)
         if action == "protect":
-            return client.protect_environment(**kwargs)
+            return await run_blocking(client.protect_environment, **kwargs)
         if action == "update_protected":
-            return client.update_protected_environment(**kwargs)
+            return await run_blocking(client.update_protected_environment, **kwargs)
         if action == "unprotect":
-            return client.unprotect_environment(**kwargs)
+            return await run_blocking(client.unprotect_environment, **kwargs)
         raise ValueError(f"Unknown action: {action}")

{gitlab_api-25.43.0 → gitlab_api-25.46.0}/gitlab_api/mcp/mcp_epics.py

@@ -5,6 +5,7 @@ Auto-generated from mcp_server.py during ecosystem standardization.
 
 from typing import Any
 
+from agent_utilities.mcp_utilities import resolve_action, run_blocking
 from fastmcp import Context, FastMCP
 from fastmcp.dependencies import Depends
 from pydantic import Field
@@ -38,14 +39,21 @@ def register_epics_tools(mcp: FastMCP):
 
         kwargs = {k: v for k, v in kwargs.items() if v is not None}
 
+        resolved = resolve_action(
+            action, {"get", "create", "update", "delete"}, service="gitlab-api"
+        )
+        if isinstance(resolved, dict):
+            return resolved
+        action = resolved
+
         if action == "get":
             if "epic_iid" in kwargs or "epic_id" in kwargs:
-                return client.get_epic(**kwargs)
-            return client.get_epics(**kwargs)
+                return await run_blocking(client.get_epic, **kwargs)
+            return await run_blocking(client.get_epics, **kwargs)
         if action == "create":
-            return client.create_epic(**kwargs)
+            return await run_blocking(client.create_epic, **kwargs)
         if action == "update":
-            return client.update_epic(**kwargs)
+            return await run_blocking(client.update_epic, **kwargs)
         if action == "delete":
-            return client.delete_epic(**kwargs)
+            return await run_blocking(client.delete_epic, **kwargs)
         raise ValueError(f"Unknown action: {action}")