bitflicker64 commented on code in PR #436:
URL: https://github.com/apache/hugegraph-ai/pull/436#discussion_r4579087485
##########
hugegraph-mcp/hugegraph_mcp/write_executor.py:
##########
@@ -323,3 +323,88 @@ def get_write_status(plan_id: str) -> dict:
store=store,
registry=DEFAULT_WRITE_EXECUTOR_REGISTRY,
).status(plan_id)
+
+
+def list_write_plans(*, status: str | None = None, limit: int = 20) -> dict:
+ if not isinstance(limit, int) or isinstance(limit, bool) or not (1 <=
limit <= 100):
+ return envelope_err(
+ ErrorType.VALIDATION_ERROR,
+ "limit must be an integer between 1 and 100.",
+ details={"reason": "invalid_limit"},
+ )
+ normalized_status: str | None = None
+ if status is not None:
+ if not isinstance(status, str) or not status.strip():
+ return envelope_err(
+ ErrorType.VALIDATION_ERROR,
+ "status must be a non-empty string when provided.",
+ details={"reason": "invalid_status"},
+ )
+ normalized_status = status.strip().upper()
+ valid_statuses = {item.value for item in PlanStatus}
+ if normalized_status not in valid_statuses:
+ return envelope_err(
+ ErrorType.VALIDATION_ERROR,
+ f"Unsupported plan status {status!r}; expected one of
{sorted(valid_statuses)}.",
+ details={"reason": "invalid_status", "status": status},
+ )
+ try:
+ store = plan_store_from_config()
+ except Exception as exc:
+ return envelope_err(
+ ErrorType.SERVER_ERROR,
+ "The durable plan store is unavailable.",
+ retryable=False,
+ details={"reason": type(exc).__name__},
+ )
+ plans = store.list_plans(status=normalized_status, limit=limit)
+ return envelope_ok({"plans": plans, "count": len(plans)})
+
+
+def cancel_write_plan(plan_id: str) -> dict:
+ if not isinstance(plan_id, str) or not plan_id.strip():
+ return envelope_err(
+ ErrorType.VALIDATION_ERROR,
+ "plan_id must be a non-empty string.",
+ details={"reason": "invalid_plan_id"},
+ )
+ cleaned_id = plan_id.strip()
+ try:
+ store = plan_store_from_config()
+ except Exception as exc:
+ return envelope_err(
+ ErrorType.SERVER_ERROR,
+ "The durable plan store is unavailable.",
+ retryable=False,
+ details={"reason": type(exc).__name__},
+ )
+ record = store.get_plan_record(cleaned_id)
+ if record is None:
+ return envelope_err(
+ ErrorType.NOT_FOUND,
+ f"Write plan {cleaned_id!r} was not found.",
+ details={"plan_id": cleaned_id},
+ )
+ current_status = str(record.get("status") or "")
+ if current_status != PlanStatus.ISSUED.value:
+ return envelope_err(
+ ErrorType.WRITE_CONFLICT,
+ f"Only ISSUED plans can be cancelled; current status is
{current_status}.",
+ details={"plan_id": cleaned_id, "status": current_status},
+ )
+ try:
+ store.transition_plan(
+ cleaned_id,
+ expected=PlanStatus.ISSUED,
+ target=PlanStatus.EXPIRED,
+ )
+ except PlanTransitionError as exc:
+ return envelope_err(
+ ErrorType.WRITE_CONFLICT,
+ f"Write plan {cleaned_id!r} could not be cancelled: {exc}",
+ details={"plan_id": cleaned_id},
+ )
+ from hugegraph_mcp.confirmation_store import ConfirmationStore
+
+ ConfirmationStore.from_config().revoke_by_plan_id(cleaned_id)
Review Comment:
Important: `revoke_by_plan_id` only finds tokens bound through
`bind_plan_id`, which `manage_graph_data` never calls, so after
`cancel_write_plan_tool` reports an edge-delete plan `EXPIRED`,
`delete_graph_data_tool(confirm=True)` with the dry-run token still drops the
edge. Bind the token after `save_plan` in `manage_graph_data`, or reject legacy
confirmation when the bound plan is no longer `ISSUED`, and add an edge-delete
cancel test.
##########
hugegraph-llm/src/hugegraph_llm/operators/index_op/build_semantic_index.py:
##########
@@ -16,25 +16,100 @@
# under the License.
import asyncio
-from typing import Any, Dict
+import json
+import os
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
from tqdm import tqdm
-from hugegraph_llm.config import huge_settings
+from hugegraph_llm.config import huge_settings, resource_path
from hugegraph_llm.indices.vector_index.base import VectorStoreBase
from hugegraph_llm.models.embeddings.base import BaseEmbedding
from hugegraph_llm.operators.hugegraph_op.schema_manager import SchemaManager
from hugegraph_llm.utils.log import log
+_VID_META_FILE = "vid_index_meta.json"
+
+
+def effective_graphspace(graph_space: Optional[str]) -> str:
+ return graph_space.strip() if isinstance(graph_space, str) and
graph_space.strip() else "DEFAULT"
+
+
+def vid_index_name_parts(graph_name: str, graph_space: Optional[str] = None)
-> tuple[str, ...]:
+ space = effective_graphspace(graph_space)
+ if space == "DEFAULT":
+ return (graph_name, "graph_vids")
+ return (f"{len(space)}_{space}", graph_name, "graph_vids_ns")
Review Comment:
Important: for a non-`DEFAULT` `graph_space`, the VID index moves from
`<graph>/graph_vids` to `<n>_<space>/<graph>/graph_vids_ns`, so after upgrade
`SemanticIdQuery` opens an empty index and semantic VID matching returns
nothing until the user rebuilds, and `clean_all_graph_index` stops removing the
old index. Fall back to or migrate the legacy `(graph_name, "graph_vids")`
index when the namespaced one does not exist.
##########
hugegraph-mcp/README.md:
##########
@@ -228,49 +260,28 @@ Structured reads remain available.
`generate_gremlin_tool(execute=false)` additi
| `HUGEGRAPH_MCP_TIMEOUT_SECONDS` | `30` | Deprecated fallback for AI timeout |
| `HUGEGRAPH_MCP_MAX_RESULT_ITEMS` | `100` | Post-materialization output item
guard; range `1..1000000` |
| `HUGEGRAPH_MCP_MAX_RESULT_BYTES` | `1048576` | Post-materialization output
byte guard; range `1..1073741824` |
-| `HUGEGRAPH_MCP_PLAN_STORE` | `sqlite` | Durable plan-store backend; only
`sqlite` is currently supported |
+| `HUGEGRAPH_MCP_PLAN_STORE` | `sqlite` | Durable plan-store backend (`sqlite`
or `postgres`) |
+| `HUGEGRAPH_MCP_PLAN_STORE_DSN` | unset | PostgreSQL connection DSN (required
when `HUGEGRAPH_MCP_PLAN_STORE=postgres`) |
| `HUGEGRAPH_MCP_WRITE_INSTANCE_COUNT` | `1` | Declared count of write-capable
MCP instances; SQLite requires exactly one |
-| `HUGEGRAPH_MCP_STATE_DIR` | `$XDG_STATE_HOME/hugegraph-mcp` or
`~/.local/state/hugegraph-mcp` | Directory containing the plan, operation, and
receipt database |
+| `HUGEGRAPH_MCP_STATE_DIR` | `$XDG_STATE_HOME/hugegraph-mcp` or
`~/.local/state/hugegraph-mcp` | Directory containing the SQLite plan,
operation, and receipt database |
+| `HUGEGRAPH_MCP_TRANSPORT` | `stdio` | MCP transport (`stdio`, `http`,
`streamable-http`, or `sse`) |
Review Comment:
Important: the HTTP transports require a Bearer token by default, configured
only through `HUGEGRAPH_MCP_BEARER_SECRET`, `HUGEGRAPH_MCP_BEARER_SCOPES` and
`HUGEGRAPH_MCP_REQUIRE_AUTH`, none of which is documented, so a user who sets
`HUGEGRAPH_MCP_TRANSPORT=streamable-http` gets 401 on every request. Add these
variables to the configuration tables in `README.md` and `README.zh-CN.md`.
##########
hugegraph-mcp/hugegraph_mcp/runtime.py:
##########
@@ -0,0 +1,302 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Runtime dependency container, FastMCP lifespan, and request Actor
context."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import contextvars
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from typing import Any
+
+from hugegraph_mcp.config import MCPConfig
+from hugegraph_mcp.events import EventBus, InMemoryEventBus, OutboxEventRelay,
OutboxSource
+from hugegraph_mcp.notifications import SubscriptionManager
+from hugegraph_mcp.plan_store import SQLitePlanStore
+from hugegraph_mcp.stores.base import (
+ Actor,
+ AsyncPlanStore,
+ SyncToAsyncPlanStoreAdapter,
+ default_stdio_actor,
+)
+from hugegraph_mcp.stores.postgres import PostgresPlanStore
+
+_CURRENT_RUNTIME: contextvars.ContextVar[RuntimeContainer | None] =
contextvars.ContextVar(
+ "hugegraph_mcp_runtime",
+ default=None,
+)
+_CURRENT_ACTOR: contextvars.ContextVar[Actor | None] = contextvars.ContextVar(
+ "hugegraph_mcp_actor",
+ default=None,
+)
+_ACTIVE_RUNTIME: RuntimeContainer | None = None
+
+
+@dataclass
+class ResourceCache:
+ """In-memory bounded cache keyed by (deployment, graphspace, graph, kind,
principal_scope)."""
+
+ schema_ttl_s: float = 30.0
+ summary_ttl_s: float = 10.0
+ embeddings_ttl_s: float = 10.0
+ _entries: dict[tuple[str, str, str, str, str], tuple[float, str | None,
dict[str, Any]]] = field(
+ default_factory=dict
+ )
+
+ def get(
+ self,
+ key: tuple[str, str, str, str, str],
+ *,
+ now: float,
+ ttl_s: float,
+ expected_fingerprint: str | None = None,
+ ) -> dict[str, Any] | None:
+ item = self._entries.get(key)
+ if item is None:
+ return None
+ stored_at, fingerprint, payload = item
+ if now - stored_at > ttl_s:
+ self._entries.pop(key, None)
+ return None
+ if expected_fingerprint is not None and fingerprint !=
expected_fingerprint:
+ self._entries.pop(key, None)
+ return None
+ return payload
+
+ def set(
+ self,
+ key: tuple[str, str, str, str, str],
+ payload: dict[str, Any],
+ *,
+ now: float,
+ fingerprint: str | None = None,
+ ) -> None:
+ self._entries[key] = (now, fingerprint, payload)
+
+ def invalidate_graph(self, deployment: str, graphspace: str, graph: str)
-> int:
+ to_delete = [key for key in self._entries if key[0] == deployment and
key[1] == graphspace and key[2] == graph]
+ for key in to_delete:
+ self._entries.pop(key, None)
+ return len(to_delete)
+
+ def clear(self) -> None:
+ self._entries.clear()
+
+
+@dataclass
+class RuntimeContainer:
+ config: MCPConfig
+ plan_store: AsyncPlanStore
+ event_bus: EventBus
+ resource_cache: ResourceCache = field(default_factory=ResourceCache)
+ subscription_manager: SubscriptionManager =
field(default_factory=SubscriptionManager)
+ outbox_relay: OutboxEventRelay | None = None
+ ready: bool = False
+ shutting_down: bool = False
+ _inflight_writes: int = 0
+ _drain_event: asyncio.Event = field(default_factory=asyncio.Event)
+ _loop: asyncio.AbstractEventLoop | None = field(default=None, init=False,
repr=False)
+
+ def __post_init__(self) -> None:
+ self._drain_event.set()
+
+ def begin_write(self) -> None:
+ if self.shutting_down:
+ raise RuntimeError("Server is shutting down; new writes are
rejected")
+ self._inflight_writes += 1
+ self._drain_event.clear()
+
+ def end_write(self) -> None:
+ if self._inflight_writes > 0:
+ self._inflight_writes -= 1
+ if self._inflight_writes == 0:
+ self._drain_event.set()
+
+ async def drain_writes(self, timeout_s: float = 10.0) -> bool:
+ self.shutting_down = True
+ self.ready = False
+ if self._inflight_writes == 0:
+ return True
+ try:
+ await asyncio.wait_for(self._drain_event.wait(), timeout=timeout_s)
+ return True
+ except TimeoutError:
+ return False
+
+ async def check_ready(self) -> tuple[bool, dict[str, str]]:
+ if self.shutting_down or not self.ready:
+ return False, {"runtime": "not_ready"}
+ checks: dict[str, str] = {}
+ try:
+ await self.plan_store.check_ready()
+ checks["plan_store"] = "ok"
+ except Exception as exc:
+ checks["plan_store"] = f"error: {exc!s}"
+ return False, checks
+ try:
+ await self.event_bus.check_ready()
+ checks["event_bus"] = "ok"
+ except Exception as exc:
+ checks["event_bus"] = f"error: {exc!s}"
+ return False, checks
+ return True, checks
+
+
+def build_runtime(config: MCPConfig | None = None) -> RuntimeContainer:
+ cfg = config or MCPConfig.from_env()
+ event_bus = InMemoryEventBus()
+ if cfg.plan_store_backend == "postgres" and cfg.plan_store_dsn:
+ plan_store: AsyncPlanStore = PostgresPlanStore(
+ cfg.plan_store_dsn,
+ deployment_id=cfg.deployment_id,
+ )
+ else:
+ sync_store = SQLitePlanStore.from_config(cfg)
+ plan_store = SyncToAsyncPlanStoreAdapter(sync_store,
event_bus=event_bus)
+ return RuntimeContainer(
+ config=cfg,
+ plan_store=plan_store,
+ event_bus=event_bus,
+ )
+
+
+def create_runtime_lifespan(config: MCPConfig | None = None):
+ """Create a FastMCP lifespan context manager bound to an immutable
MCPConfig."""
+
+ async def _fanout_events(runtime: RuntimeContainer) -> None:
+ async for event in runtime.event_bus.subscribe():
+ try:
+ runtime.resource_cache.invalidate_graph(
+ event.deployment,
+ event.graphspace,
+ event.graph,
+ )
+ await runtime.subscription_manager.dispatch(event)
+ except Exception:
+ # Never let a single failing subscriber callback terminate
event fan-out.
+ continue
+
+ @asynccontextmanager
+ async def _lifespan(server: Any) -> AsyncIterator[RuntimeContainer]:
+ global _ACTIVE_RUNTIME
+ runtime = build_runtime(config)
+ _ACTIVE_RUNTIME = runtime
+ if server is not None:
+ with contextlib.suppress(Exception):
+ server._hugegraph_runtime = runtime
+ token = _CURRENT_RUNTIME.set(runtime)
+ actor_token = _CURRENT_ACTOR.set(default_stdio_actor())
+ fanout_task: asyncio.Task[None] | None = None
+ try:
+ runtime._loop = asyncio.get_running_loop()
+ if hasattr(runtime.plan_store, "prepare"):
+ await runtime.plan_store.prepare() # type:
ignore[attr-defined]
+ await runtime.plan_store.check_ready()
+ fanout_task = asyncio.create_task(_fanout_events(runtime))
+ await asyncio.sleep(0)
+ if isinstance(runtime.plan_store, OutboxSource):
+ runtime.outbox_relay = OutboxEventRelay(
Review Comment:
Important: the relay starts at `initial_seq=0` and nothing deletes from
`event_outbox`, so every restart republishes the whole event history,
invalidating caches and sending `resources/updated` for old writes, and the
replay grows with every write. Start the cursor at `MAX(seq)` on startup and
prune old outbox rows.
##########
hugegraph-mcp/hugegraph_mcp/stores/postgres.py:
##########
@@ -0,0 +1,1426 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""PostgreSQL authoritative PlanStore with optimistic fencing and
transactional outbox."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import time
+import uuid
+from typing import Any, Protocol
+
+from hugegraph_mcp.events import ResourceEvent
+from hugegraph_mcp.plan_store import PlanStoreUnavailableError,
PlanTransitionError
+from hugegraph_mcp.stores.base import (
+ Actor,
+ Lease,
+ LeaseConflictError,
+ PlanNotFoundError,
+ PlanOutcome,
+ PlanView,
+)
+from hugegraph_mcp.write_plan import (
+ ApplyReceipt,
+ ApplyStatus,
+ GraphTarget,
+ OperationPlan,
+ PlanStatus,
+ WritePlan,
+ aggregate_plan_status,
+ can_transition,
+ canonical_plan_json,
+)
+
+POSTGRES_DDL = """
+CREATE TABLE IF NOT EXISTS write_plans (
+ plan_id TEXT PRIMARY KEY,
+ tool_name TEXT NOT NULL,
+ owner_tenant TEXT NOT NULL,
+ owner_subject TEXT NOT NULL,
+ graphspace TEXT NOT NULL,
+ graph TEXT NOT NULL,
+ payload_json JSONB NOT NULL,
+ payload_digest TEXT NOT NULL,
+ status TEXT NOT NULL,
+ version BIGINT NOT NULL DEFAULT 1,
+ fence BIGINT NOT NULL DEFAULT 0,
+ lease_holder TEXT,
+ lease_expires_at TIMESTAMPTZ,
+ confirmed_at TIMESTAMPTZ,
+ expires_at TIMESTAMPTZ NOT NULL,
+ summary_json JSONB NOT NULL DEFAULT '{}'::jsonb,
+ created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+ updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+ALTER TABLE write_plans
+ ADD COLUMN IF NOT EXISTS confirmed_at TIMESTAMPTZ;
+
+CREATE TABLE IF NOT EXISTS plan_operations (
+ plan_id TEXT NOT NULL REFERENCES write_plans(plan_id) ON DELETE CASCADE,
+ operation_id TEXT NOT NULL,
+ ordinal INTEGER NOT NULL DEFAULT 0,
+ kind TEXT NOT NULL,
+ target_json JSONB NOT NULL,
+ status TEXT NOT NULL DEFAULT 'ISSUED',
+ attempt INTEGER NOT NULL DEFAULT 0,
+ attempt_token TEXT,
+ reconciled BOOLEAN NOT NULL DEFAULT FALSE,
+ apply_status TEXT,
+ receipt_json JSONB,
+ recorded_at TIMESTAMPTZ,
+ updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+ PRIMARY KEY (plan_id, operation_id)
+);
+
+ALTER TABLE plan_operations
+ ADD COLUMN IF NOT EXISTS ordinal INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE plan_operations
+ ADD COLUMN IF NOT EXISTS status TEXT NOT NULL DEFAULT 'ISSUED';
+ALTER TABLE plan_operations
+ ADD COLUMN IF NOT EXISTS attempt INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE plan_operations
+ ADD COLUMN IF NOT EXISTS attempt_token TEXT;
+ALTER TABLE plan_operations
+ ADD COLUMN IF NOT EXISTS reconciled BOOLEAN NOT NULL DEFAULT FALSE;
+ALTER TABLE plan_operations
+ ADD COLUMN IF NOT EXISTS updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW();
+
+CREATE TABLE IF NOT EXISTS event_outbox (
+ seq BIGSERIAL PRIMARY KEY,
+ event_id TEXT NOT NULL UNIQUE,
+ deployment TEXT NOT NULL,
+ graphspace TEXT NOT NULL,
+ graph TEXT NOT NULL,
+ uri TEXT NOT NULL,
+ kind TEXT NOT NULL,
+ resource_version BIGINT NOT NULL,
+ txid BIGINT NOT NULL DEFAULT txid_current(),
+ created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+ALTER TABLE event_outbox
+ ADD COLUMN IF NOT EXISTS txid BIGINT NOT NULL DEFAULT txid_current();
+
+CREATE INDEX IF NOT EXISTS idx_event_outbox_created ON event_outbox (seq);
+CREATE INDEX IF NOT EXISTS idx_event_outbox_txid ON event_outbox (seq, txid);
+"""
+
+
+class AsyncDBConnection(Protocol):
+ async def execute(self, query: str, params: tuple[Any, ...] = ()) -> Any:
...
+
+ async def fetchone(self, query: str, params: tuple[Any, ...] = ()) ->
dict[str, Any] | None: ...
+
+ async def fetchall(self, query: str, params: tuple[Any, ...] = ()) ->
list[dict[str, Any]]: ...
+
+
+class AsyncDBPool(Protocol):
+ async def acquire(self) -> AsyncDBConnection: ...
+
+ async def release(self, conn: AsyncDBConnection, exc: BaseException | None
= None) -> None: ...
+
+ async def close(self) -> None: ...
+
+
+class PostgresPlanStore:
+ """Shared multi-instance PlanStore backed by PostgreSQL + transactional
outbox."""
+
+ def __init__(
+ self,
+ dsn: str,
+ *,
+ pool: AsyncDBPool | None = None,
+ deployment_id: str = "default",
+ ) -> None:
+ if not dsn or not dsn.strip():
+ raise PlanStoreUnavailableError("PostgresPlanStore requires a
non-empty DSN")
+ self._dsn = dsn.strip()
+ self._pool = pool
+ self._deployment_id = deployment_id or "default"
+
+ async def prepare(self) -> None:
+ pool = self._require_pool()
+ conn = await pool.acquire()
+ try:
+ for statement in [stmt.strip() for stmt in POSTGRES_DDL.split(";")
if stmt.strip()]:
+ await conn.execute(statement)
+ finally:
+ await pool.release(conn)
+
+ def _require_pool(self) -> AsyncDBPool:
+ if self._pool is None:
+ self._pool = _create_psycopg_pool(self._dsn)
+ return self._pool
+
+ async def fetch_outbox_since(
+ self,
+ after_seq: int,
+ *,
+ limit: int = 100,
+ ) -> list[tuple[int, ResourceEvent]]:
+ pool = self._require_pool()
+ conn = await pool.acquire()
+ try:
+ rows = await conn.fetchall(
+ """
+ SELECT seq, event_id, deployment, graphspace, graph, uri, kind,
+ resource_version, EXTRACT(EPOCH FROM created_at) AS
created_at
+ FROM event_outbox
+ WHERE seq > %s
+ AND txid < txid_snapshot_xmin(txid_current_snapshot())
Review Comment:
Important: `txid` is assigned at the transaction's first `FOR UPDATE` but
`seq` at the outbox insert, so a transaction with a lower `txid` and higher
`seq` can commit first; the relay then moves `last_seq` past the uncommitted
lower `seq`, and that event is never delivered. Order by and track the cursor
as `(txid, seq)`, which is gap-free for rows with `txid` below `xmin`.
##########
hugegraph-mcp/hugegraph_mcp/server.py:
##########
@@ -444,7 +736,7 @@ def design_schema_tool(operations: list[dict] | None =
None) -> dict:
)
[email protected]()
+@_register_tool
def apply_schema_tool(
Review Comment:
Minor: this tool description still says apply rejects schema append, but
this PR makes `append_vertex_label` and `append_edge_label` confirmable, so MCP
clients are told not to use them. List both as supported and keep only
eliminate and remove/drop as rejected.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]