fix(client,tests,langchain): port sentinel, lazy connect, schema parser

- AsyncCoordinodeClient: port default None → distinguishes omitted from
  explicit 7080; fixes silent conflict when caller passes explicit port
  matching 7080 but host string embeds different port
- CoordinodeClient: same port sentinel change; add lazy connect in _run()
  so client is usable outside context manager; add public close() method
  reused by __exit__ (fixes AttributeError in langchain/llama-index teardown)
- Host:port parsing tests: use AsyncCoordinodeClient directly (no event loop
  created → no loop leak); add test for explicit-port-conflict raise
- test_sdk.py: remove stale "xfail until wired" section comment
- test_types.py: rename _FakeMap.fields → entries to match proto accessor
- langchain graph.py: rewrite _parse_schema to match get_schema_text() format
  ("Edge types:" header, inline "(properties: ...)" on bullet lines)

Author: polaz

coordinode/client.py

@@ -106,24 +106,27 @@ class AsyncCoordinodeClient:
     def __init__(
         self,
         host: str = "localhost",
-        port: int = 7080,
+        port: int | None = None,
         *,
         tls: bool = False,
         timeout: float = 30.0,
     ) -> None:
         # Support "host:port" as a single string (common gRPC convention).
         # _HOST_PORT_RE matches "hostname:port" and "[IPv6]:port" but not bare
         # IPv6 addresses, avoiding the ambiguity of rsplit(":", 1) on "::1".
+        # port=None means "not specified by caller" — distinct from explicit port=7080.
         m = _HOST_PORT_RE.match(host)
         if m:
             parsed_port = int(m.group(2))
-            if port != 7080 and port != parsed_port:
+            if port is not None and port != parsed_port:
                 raise ValueError(
                     f"Conflicting ports: port={port!r} (argument) vs {parsed_port!r} "
                     f"(embedded in host={host!r}). Specify the port in the host string "
                     "only, or use the port argument only."
                 )
             host, port = m.group(1), parsed_port
+        if port is None:
+            port = 7080
         self._host = host
         self._port = port
         self._tls = tls
@@ -336,23 +339,36 @@ class CoordinodeClient:
     def __init__(
         self,
         host: str = "localhost",
-        port: int = 7080,
+        port: int | None = None,
         *,
         tls: bool = False,
         timeout: float = 30.0,
     ) -> None:
         self._async = AsyncCoordinodeClient(host, port, tls=tls, timeout=timeout)
         self._loop = asyncio.new_event_loop()
+        self._connected = False
 
     def __enter__(self) -> CoordinodeClient:
-        self._loop.run_until_complete(self._async.connect())
+        if not self._connected:
+            self._loop.run_until_complete(self._async.connect())
+            self._connected = True
         return self
 
     def __exit__(self, *_: Any) -> None:
-        self._loop.run_until_complete(self._async.close())
-        self._loop.close()
+        self.close()
+
+    def close(self) -> None:
+        """Close the underlying gRPC channel and event loop."""
+        if self._connected:
+            self._loop.run_until_complete(self._async.close())
+            self._connected = False
+        if not self._loop.is_closed():
+            self._loop.close()
 
     def _run(self, coro: Any) -> Any:
+        if not self._connected:
+            self._loop.run_until_complete(self._async.connect())
+            self._connected = True
         return self._loop.run_until_complete(coro)
 
     def cypher(

langchain-coordinode/langchain_coordinode/graph.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import re
 from typing import Any
 
 from langchain_community.graphs.graph_store import GraphStore
@@ -113,16 +114,23 @@ def _parse_schema(schema_text: str) -> dict[str, Any]:
             "relationships": [{"start": "A", "type": "REL", "end": "B"}, ...],
         }
 
-    CoordiNode's ``/schema`` endpoint returns a human-readable text; we do a
-    best-effort parse here. For reliable structured access use the gRPC
-    ``SchemaService`` directly.
+    CoordiNode's schema text format (from ``get_schema_text()``)::
+
+        Node labels:
+          - Person (properties: name: STRING, age: INT64)
+          - Company
+
+        Edge types:
+          - KNOWS (properties: since: INT64)
+          - WORKS_FOR
+
+    We parse inline ``(properties: ...)`` lists on each bullet line.
+    For reliable structured access use the gRPC ``SchemaService`` directly.
     """
     node_props: dict[str, list[dict[str, str]]] = {}
     rel_props: dict[str, list[dict[str, str]]] = {}
     relationships: list[dict[str, str]] = []
 
-    current_label: str | None = None
-    current_type: str | None = None
     in_nodes = False
     in_rels = False
 
@@ -134,42 +142,28 @@ def _parse_schema(schema_text: str) -> dict[str, Any]:
         if stripped.lower().startswith("node labels"):
             in_nodes, in_rels = True, False
             continue
-        if stripped.lower().startswith("relationship types"):
+        # Accept both "Edge types:" (current format) and "Relationship types:" (legacy)
+        if stripped.lower().startswith("edge types") or stripped.lower().startswith("relationship types"):
             in_nodes, in_rels = False, True
             continue
 
-        if in_nodes:
-            if stripped.startswith("-") or stripped.startswith("*"):
-                label = stripped.lstrip("-* ").split()[0].strip(":")
-                current_label = label
-                node_props.setdefault(label, [])
-            elif current_label and ":" in stripped:
-                parts = stripped.split(":", 1)
-                prop = parts[0].strip()
-                typ = parts[1].strip().upper()
-                node_props[current_label].append({"property": prop, "type": typ})
-
-        if in_rels:
-            if stripped.startswith("-") or stripped.startswith("*"):
-                rel = stripped.lstrip("-* ").split()[0].strip()
-                current_type = rel
-                rel_props.setdefault(rel, [])
-            elif current_type and "->" in stripped:
-                parts = stripped.split("->")
-                start = parts[0].strip().strip("(: )")
-                end = parts[-1].strip().strip("(: )")
-                relationships.append(
-                    {
-                        "start": start,
-                        "type": current_type,
-                        "end": end,
-                    }
-                )
-            elif current_type and ":" in stripped:
-                parts = stripped.split(":", 1)
-                prop = parts[0].strip()
-                typ = parts[1].strip().upper()
-                rel_props[current_type].append({"property": prop, "type": typ})
+        if (in_nodes or in_rels) and (stripped.startswith("-") or stripped.startswith("*")):
+            # Extract name (part before optional "(properties: ...)")
+            name = stripped.lstrip("-* ").split("(")[0].strip()
+            if not name:
+                continue
+            # Parse inline properties: "- Label (properties: prop1: TYPE, prop2: TYPE)"
+            props: list[dict[str, str]] = []
+            m = re.search(r"\(properties:\s*([^)]+)\)", stripped)
+            if m:
+                for prop_str in m.group(1).split(","):
+                    kv = prop_str.strip().split(":", 1)
+                    if len(kv) == 2:
+                        props.append({"property": kv[0].strip(), "type": kv[1].strip()})
+            if in_nodes:
+                node_props[name] = props
+            else:
+                rel_props[name] = props
 
     return {
         "node_props": node_props,

tests/integration/test_sdk.py

@@ -256,24 +256,30 @@ def test_hybrid_search_returns_results(client):
 
 
 def test_hostport_string_parsing():
-    """CoordinodeClient("host:port") must parse correctly."""
-    c = CoordinodeClient("localhost:7080")
-    assert c._async._host == "localhost"
-    assert c._async._port == 7080
+    """AsyncCoordinodeClient("host:port") must parse correctly."""
+    c = AsyncCoordinodeClient("localhost:7080")
+    assert c._host == "localhost"
+    assert c._port == 7080
 
 
 def test_ipv6_bracket_parsing():
     """Bracketed IPv6 [::1]:7080 must parse correctly."""
-    c = CoordinodeClient("[::1]:7080")
-    assert c._async._host == "[::1]"
-    assert c._async._port == 7080
+    c = AsyncCoordinodeClient("[::1]:7080")
+    assert c._host == "[::1]"
+    assert c._port == 7080
 
 
 def test_bare_ipv6_not_parsed():
     """Unbracketed IPv6 must NOT be misinterpreted as host:port."""
-    c = CoordinodeClient("::1")
-    assert c._async._host == "::1"
-    assert c._async._port == 7080  # default unchanged
+    c = AsyncCoordinodeClient("::1")
+    assert c._host == "::1"
+    assert c._port == 7080  # default unchanged
+
+
+def test_explicit_port_conflict_raises():
+    """Explicit port that conflicts with host-embedded port must raise ValueError."""
+    with pytest.raises(ValueError, match="Conflicting ports"):
+        AsyncCoordinodeClient("db.example.com:7443", port=7080)
 
 
 # ── Async client ──────────────────────────────────────────────────────────────
@@ -303,7 +309,7 @@ async def test_async_create_node():
         await c.cypher("MATCH (n:AsyncTest {tag: $tag}) DELETE n", params={"tag": tag})
 
 
-# ── Vector search (xfail until wired) ─────────────────────────────────────────
+# ── Vector search ─────────────────────────────────────────────────────────────
 
 
 def test_vector_search_returns_results(client):

tests/unit/test_types.py

@@ -36,8 +36,8 @@ def __init__(self, values):
 
 
 class _FakeMap:
-    def __init__(self, fields):
-        self.fields = dict(fields)
+    def __init__(self, entries):
+        self.entries = dict(entries)
 
 
 class _FakePV: