machinaos 0.0.76 → 0.0.78

package/server/services/llm/config.py

@@ -109,6 +109,13 @@ def detect_provider_from_model(model: str) -> str:
 
 
 def is_model_valid_for_provider(model: str, provider: str) -> bool:
+    # Open-world providers — OpenRouter is a multi-vendor proxy, ollama
+    # and lmstudio serve user-installed local models whose names don't
+    # match any "lmstudio"/"ollama" substring. Treat as always-valid;
+    # the upstream API will 404 a genuinely missing model. See the
+    # mirror in services/ai.py for the full rationale.
+    if provider in ('openrouter', 'ollama', 'lmstudio'):
+        return True
     cfg = PROVIDER_CONFIGS.get(provider)
     if not cfg:
         return True

package/server/services/llm/factory.py

@@ -12,8 +12,14 @@ logger = get_logger(__name__)
 # Providers with dedicated SDK implementations
 _DEDICATED_PROVIDERS = frozenset({"anthropic", "openai", "gemini", "openrouter"})
 
-# All providers supported by native SDK path (dedicated + OpenAI-compatible via base_url)
-NATIVE_PROVIDERS = _DEDICATED_PROVIDERS | frozenset({"xai", "deepseek", "kimi", "mistral"})
+# All providers supported by native SDK path (dedicated + OpenAI-compatible via base_url).
+# Local servers (ollama, lmstudio) expose OpenAI-compatible /v1 endpoints, so they fall
+# through to OpenAIProvider with base_url from llm_defaults.json — same path as deepseek/
+# kimi/mistral. The user's custom URL rides via the existing {provider}_proxy credential.
+NATIVE_PROVIDERS = _DEDICATED_PROVIDERS | frozenset({
+    "xai", "deepseek", "kimi", "mistral",
+    "ollama", "lmstudio",
+})
 
 
 def create_provider(

package/server/services/memory/__init__.py

@@ -0,0 +1,52 @@
+"""Conversation-memory utilities — package entrypoint.
+
+Reorganised from the single-file ``services/memory.py`` so each
+storage format / concern owns its own module:
+
+  - :mod:`services.memory.markdown` — markdown parse/append/trim
+    (used by aiAgent / chatAgent / deep_agent / rlm_agent)
+  - :mod:`services.memory.jsonl` — Anthropic Messages JSONL
+    parse/append/trim (used by claude_code_agent's session bridge)
+  - :mod:`services.memory.vector_store` — per-session
+    ``InMemoryVectorStore`` for long-term archival
+  - :mod:`services.memory.state` — orchestration: clear every store
+    keyed by an agent's conversational scope
+
+Public surface is re-exported here so existing
+``from services.memory import …`` imports keep working — the file
+became a package in-place.
+"""
+
+from services.memory.markdown import (
+    append_to_memory_markdown,
+    parse_memory_markdown,
+    trim_markdown_window,
+)
+from services.memory.vector_store import (
+    _memory_vector_stores,
+    get_memory_vector_store,
+)
+from services.memory.state import clear_agent_session_state
+from services.memory.jsonl import (
+    append_message,
+    parse_jsonl,
+    trim_window,
+)
+
+__all__ = [
+    # Markdown helpers — used by every agent bridge (aiAgent /
+    # chatAgent / deep_agent / rlm_agent / claude_code_agent).
+    "parse_memory_markdown",
+    "append_to_memory_markdown",
+    "trim_markdown_window",
+    # Vector-store helpers.
+    "_memory_vector_stores",
+    "get_memory_vector_store",
+    # Orchestration.
+    "clear_agent_session_state",
+    # JSONL helpers — standalone primitive, not currently used by any
+    # agent bridge but tested + kept for future SDK migration.
+    "parse_jsonl",
+    "append_message",
+    "trim_window",
+]

package/server/services/memory/jsonl.py

@@ -0,0 +1,80 @@
+"""Standard-JSONL conversation-memory helpers.
+
+Lines are Anthropic Messages API objects: ``{"role": "user"|"assistant",
+"content": str | List[ContentBlock], ...}``. Extra metadata
+(``timestamp``, ``session_id``, ``model``, ...) rides alongside
+``role`` / ``content`` and is preserved on round-trip; standard parsers
+(Anthropic SDK, LangChain converters) ignore unknown keys.
+
+Used by :mod:`nodes.agent.claude_code_agent` (session memory) via
+:func:`services.cli_agent.service.AICliService.run_batch`.
+"""
+
+import json
+from typing import Any, List, Tuple
+
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
+
+
+def parse_jsonl(text: str) -> List[BaseMessage]:
+    """Standard JSONL -> LangChain ``BaseMessage`` list.
+
+    Tool-call content blocks collapse to text; rows with unknown roles
+    or unparseable JSON are skipped (forward compatibility).
+    """
+    if not text:
+        return []
+    out: List[BaseMessage] = []
+    for line in text.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            obj = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        role = obj.get("role")
+        content = obj.get("content")
+        if isinstance(content, list):
+            content = " ".join(
+                blk.get("text", "") if isinstance(blk, dict) else str(blk)
+                for blk in content
+                if isinstance(blk, dict) and blk.get("type") == "text"
+            )
+        if not isinstance(content, str):
+            continue
+        if role == "user":
+            out.append(HumanMessage(content=content))
+        elif role == "assistant":
+            out.append(AIMessage(content=content))
+    return out
+
+
+def append_message(
+    text: str, role: str, content: str, **metadata: Any,
+) -> str:
+    """Append one Anthropic Messages-format line to a JSONL string.
+
+    Metadata fields ride alongside ``role`` / ``content``. Always emits
+    a trailing newline so successive appends concatenate cleanly.
+    """
+    line = json.dumps(
+        {"role": role, "content": content, **metadata}, ensure_ascii=False,
+    )
+    if text and not text.endswith("\n"):
+        text = text + "\n"
+    return (text or "") + line + "\n"
+
+
+def trim_window(text: str, window_size: int) -> Tuple[str, List[str]]:
+    """Keep the last ``window_size * 2`` lines (~ N user/assistant
+    pairs). Returns ``(trimmed, removed)``. Removed lines are returned
+    verbatim so callers can hand them to the long-term vector store.
+    """
+    lines = [ln for ln in (text or "").splitlines() if ln.strip()]
+    keep = window_size * 2
+    if len(lines) <= keep:
+        return text, []
+    removed = lines[:-keep]
+    trimmed = "\n".join(lines[-keep:]) + "\n"
+    return trimmed, removed

package/server/services/memory/markdown.py

@@ -0,0 +1,65 @@
+"""Markdown-based conversation-memory helpers.
+
+Parse, append, and trim conversation history stored in the bespoke
+``### **Human/Assistant** (timestamp)`` markdown format. Used by
+aiAgent, chatAgent, deep_agent, and rlm_agent for persistent memory
+across turns. The claude_code_agent bridge uses the JSONL helpers in
+:mod:`services.memory.jsonl` instead.
+"""
+
+import re
+from datetime import datetime
+from typing import List
+
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
+
+
+def parse_memory_markdown(content: str) -> List[BaseMessage]:
+    """Parse markdown memory content into LangChain messages.
+
+    Markdown format:
+        ### **Human** (timestamp)
+        message content
+
+        ### **Assistant** (timestamp)
+        response content
+    """
+    messages: List[BaseMessage] = []
+    pattern = r'### \*\*(Human|Assistant)\*\*[^\n]*\n(.*?)(?=\n### \*\*|$)'
+    for role, text in re.findall(pattern, content, re.DOTALL):
+        text = text.strip()
+        if text:
+            msg_class = HumanMessage if role == "Human" else AIMessage
+            messages.append(msg_class(content=text))
+    return messages
+
+
+def append_to_memory_markdown(content: str, role: str, message: str) -> str:
+    """Append a message to markdown memory content."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    label = "Human" if role == "human" else "Assistant"
+    entry = f"\n### **{label}** ({ts})\n{message}\n"
+    # Remove the empty-state placeholder if present.
+    return content.replace("*No messages yet.*\n", "") + entry
+
+
+def trim_markdown_window(content: str, window_size: int) -> tuple:
+    """Keep the last ``window_size`` message PAIRS; return
+    ``(trimmed_content, removed_texts)``. Removed texts are returned
+    so callers can hand them to the long-term vector store."""
+    pattern = r'(### \*\*(Human|Assistant)\*\*[^\n]*\n.*?)(?=\n### \*\*|$)'
+    blocks = [m[0] for m in re.findall(pattern, content, re.DOTALL)]
+
+    if len(blocks) <= window_size * 2:
+        return content, []
+
+    keep = blocks[-(window_size * 2):]
+    removed = blocks[:-(window_size * 2)]
+
+    removed_texts: List[str] = []
+    for block in removed:
+        match = re.search(r"\n(.*)$", block, re.DOTALL)
+        if match:
+            removed_texts.append(match.group(1).strip())
+
+    return "# Conversation History\n" + "\n".join(keep), removed_texts

package/server/services/memory/state.py

@@ -0,0 +1,112 @@
+"""Cross-store agent-session state-clear orchestration.
+
+"Memory" from the user's perspective is not just the markdown
+transcript — it's every piece of state an agent reuses across iterations
+of a conversation. ``simpleMemory.memory_content`` is the visible part;
+the long-term vector store and ``TodoService`` plan-work-update lists
+are the invisible parts that quietly bloat subsequent runs (notably
+``task_agent``, whose default skill bundle instructs the LLM to read
+accumulated todos every run).
+
+When a ``memory_node_id`` is provided, the simpleMemory node's own
+fields (``memory_content``, ``memory_jsonl``, ``last_session_id``) are
+also reset to defaults via ``database.save_node_parameters`` so the
+claude_code_agent JSONL bridge surface clears alongside.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+DEFAULT_MEMORY_CONTENT = "# Conversation History\n\n*No messages yet.*\n"
+
+
+async def clear_agent_session_state(
+    session_id: str,
+    workflow_id: str = None,
+    clear_long_term: bool = False,
+    memory_node_id: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Clear every store keyed by an agent's conversational scope.
+
+    ``TodoService`` is keyed by ``ctx.workflow_id or ctx.node_id or
+    "default"`` (see ``server/nodes/tool/write_todos.py``). We clear all
+    three candidate keys to match whichever fallback the agent actually
+    used at write time.
+
+    Args:
+        session_id: ``simpleMemory`` node's ``session_id`` parameter.
+        workflow_id: Active workflow id (passed by the frontend so we
+            can clear ``TodoService`` entries written under it).
+        clear_long_term: When ``True``, drop the per-session vector
+            store too.
+        memory_node_id: When provided, reset the simpleMemory node's
+            ``memory_content`` to the default placeholder and wipe
+            ``memory_jsonl`` + ``last_session_id``. Without this the
+            JSONL bridge fields stay populated and ``--resume`` retries
+            stale UUIDs. Frontend-driven legacy clears omit this and
+            handle markdown reset client-side.
+
+    Returns:
+        Dict with ``cleared_vector_store`` (bool), ``cleared_todo_keys``
+        (list[str]), and ``cleared_memory_node`` (bool) for
+        caller-visible diagnostics.
+    """
+    # The live vector-store cache lives in ``services.ai`` (the dict in
+    # ``services.memory.vector_store`` is dormant — future cleanup will
+    # consolidate). Lazy import keeps ``services.ai``'s heavy LangChain
+    # deps off the hot path.
+    from services.ai import _memory_vector_stores as _live_vector_stores
+    from services.todo_service import get_todo_service
+
+    cleared_vector_store = False
+    if clear_long_term and session_id in _live_vector_stores:
+        del _live_vector_stores[session_id]
+        cleared_vector_store = True
+        logger.info(f"[Memory] Cleared vector store for session '{session_id}'")
+
+    todo_service = get_todo_service()
+    cleared_todo_keys: List[str] = []
+    seen = set()
+    for key in (workflow_id, session_id, "default"):
+        if key and key not in seen:
+            seen.add(key)
+            todo_service.clear(key)
+            cleared_todo_keys.append(key)
+
+    cleared_memory_node = False
+    if memory_node_id:
+        from services.plugin.deps import get_database
+
+        db = get_database()
+        params = await db.get_node_parameters(memory_node_id) or {}
+        params["memory_content"] = DEFAULT_MEMORY_CONTENT
+        # Wipe `last_session_id` so claude_code_agent starts a fresh
+        # session on next spawn instead of `--resume`-ing into the now-
+        # cleared transcript. Drop any orphan JSONL field from the
+        # earlier bridge revision.
+        params["last_session_id"] = None
+        params.pop("memory_jsonl", None)
+        await db.save_node_parameters(memory_node_id, params)
+        cleared_memory_node = True
+        logger.info(
+            "[Memory] Cleared simpleMemory node fields memory_node=%s "
+            "(memory_content reset + last_session_id wiped)",
+            memory_node_id,
+        )
+
+    logger.info(
+        "[Memory] Cleared agent session state session=%s workflow_id=%s "
+        "vector_store=%s todo_keys=%s memory_node=%s",
+        session_id, workflow_id, cleared_vector_store, cleared_todo_keys,
+        cleared_memory_node,
+    )
+
+    return {
+        "cleared_vector_store": cleared_vector_store,
+        "cleared_todo_keys": cleared_todo_keys,
+        "cleared_memory_node": cleared_memory_node,
+    }

package/server/services/memory/vector_store.py

@@ -0,0 +1,40 @@
+"""Per-session ``InMemoryVectorStore`` for long-term memory archival.
+
+Note: a duplicate dict ``_memory_vector_stores`` lives in
+:mod:`services.ai`. ``services.memory.state.clear_agent_session_state``
+clears the live (``services.ai``) one — this module's dict is an
+intentional second copy that future cleanup will consolidate. Keep both
+for now; the documented duplication is preserved verbatim.
+"""
+
+from typing import Any, Dict
+
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+# Per-``session_id`` cache. The live cache used by aiAgent etc. lives
+# in ``services.ai``; this dict is the package-private counterpart for
+# JSONL-bridge consumers and is referenced by state-clear orchestration.
+_memory_vector_stores: Dict[str, Any] = {}
+
+
+def get_memory_vector_store(session_id: str):
+    """Get or create an ``InMemoryVectorStore`` for a session.
+
+    Returns ``None`` (with a warning) when the optional LangChain
+    HuggingFace dep is missing — long-term archival is best-effort.
+    """
+    if session_id not in _memory_vector_stores:
+        try:
+            from langchain_core.vectorstores import InMemoryVectorStore
+            from langchain_huggingface import HuggingFaceEmbeddings
+
+            embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-small-en-v1.5")
+            _memory_vector_stores[session_id] = InMemoryVectorStore(embeddings)
+            logger.debug(f"[Memory] Created vector store for session '{session_id}'")
+        except ImportError as exc:
+            logger.warning(f"[Memory] Vector store not available: {exc}")
+            return None
+    return _memory_vector_stores[session_id]

package/server/services/model_registry.py

@@ -235,6 +235,82 @@ class ModelRegistryService:
 
         return None
 
+    def register_local_model(
+        self,
+        provider: str,
+        model_id: str,
+        params: Dict[str, Any],
+    ) -> None:
+        """Register an Ollama / LM Studio model with its actual params.
+
+        Called from ``validate_local_llm`` after the official SDK probe
+        (``ollama.AsyncClient.ps()`` / ``lmstudio.AsyncClient.llm.list_loaded()``)
+        returns each currently-loaded model with its typed params:
+        ``context_length`` (live n_ctx the server enforces),
+        ``vision`` / ``supports_tools`` capability flags, and metadata
+        (``architecture``, ``param_size``, ``quantization``). The sync
+        ``get_context_length`` / ``get_max_output_tokens`` lookups find
+        this entry first, so chat / agent execution honour the real
+        n_ctx the server is serving — no JSON guess, no string parsing.
+
+        Stored under the same ``{provider}/{local_id}`` key shape as
+        cloud models so ``get_model_info``'s waterfall matches without
+        any per-provider branching. ``provider`` is canonical
+        (``ollama`` / ``lmstudio``).
+
+        Idempotent: a re-validation overwrites the prior entry.
+
+        Persisted to the same ``model_registry.json`` cache the
+        OpenRouter refresh writes — the entry survives a server
+        restart, so the user doesn't have to re-click "Fetch" every
+        time the process bounces just to keep the n_ctx context
+        registered for their local model.
+        """
+        ctx = int(params.get("context_length") or 0)
+        max_out = int(params.get("max_output_tokens") or 0)
+        # Default max_output to 25% of context (OpenRouter convention for
+        # local models), capped at 4096 — local backends rarely benefit
+        # from larger budgets and overcommitting eats into the prompt.
+        if not max_out and ctx:
+            max_out = min(4096, max(512, ctx // 4))
+
+        # Capability flags + metadata from the SDK probe go into
+        # `supported_parameters` so they survive the JSON roundtrip via
+        # `ModelInfo.to_dict` / `from_dict`. Cloud models populate this
+        # from OpenRouter's listing; for locals we use it as a typed
+        # capability bag so downstream code (tool-binding, vision UI
+        # gating) can read the same fields regardless of provider.
+        supported: List[str] = []
+        if params.get("supports_tools"):
+            supported.append("tools")
+        if params.get("vision"):
+            supported.append("vision")
+
+        # Match the user-friendly temperature default for OpenAI-compat
+        # local servers (0..2 range — same as the JSON default).
+        info = ModelInfo(
+            id=f"{provider}/{model_id}",
+            name=model_id,
+            provider=provider,
+            local_id=model_id,
+            context_length=ctx,
+            max_output_tokens=max_out,
+            temperature_range=(0.0, 2.0),
+            supported_parameters=supported,
+        )
+        self._models[f"{provider}/{model_id}"] = info
+        logger.info(
+            "[%s] registered model %s (ctx=%s, max_out=%s, tools=%s, vision=%s)",
+            provider, model_id, ctx, max_out,
+            params.get("supports_tools", False), params.get("vision", False),
+        )
+        # Persist so the entry survives process restart.
+        try:
+            self._save_cache()
+        except Exception as e:  # noqa: BLE001 — best-effort persistence
+            logger.warning("Failed to persist local model entry %s/%s: %s",
+                           provider, model_id, e)
+
     def get_max_output_tokens(self, model: str, provider: str) -> int:
         """Get max output tokens: registry -> llm_defaults -> 4096."""
         info = self.get_model_info(model, provider)

package/server/services/node_allowlist.py

@@ -29,32 +29,88 @@ class NodeAllowlistService:
 
         Response shape:
             show_all: bool
-                true  -> do not filter the palette; every node is visible.
+                true  -> do not filter the palette; every node is visible
+                         (still subject to disabled_groups + disabled_nodes).
                 false -> show only node types listed in enabled_nodes.
             enabled_nodes: list[str]
                 Only meaningful when show_all is false.
+            disabled_groups: list[str]
+                Absolute blocklist. A node whose first group matches any
+                entry here is hidden in BOTH normal and dev mode, even
+                if listed in enabled_nodes. Use to disable an entire
+                backend group (e.g. 'android' hides all 16 Android
+                service nodes + androidTool).
+            disabled_nodes: list[str]
+                Absolute blocklist by exact node-type identifier. Same
+                mode-independent enforcement as disabled_groups; use
+                for one-off types whose group label doesn't match
+                (e.g. 'android_agent' belongs to the 'agent' group).
+            disabled_credential_categories: list[str]
+                Absolute blocklist for the Credentials Modal — every
+                provider whose `category` matches an entry here is
+                hidden from the modal AND its category header is
+                stripped. Use to disable an entire credential category
+                (e.g. 'android' hides the Android relay panel + the
+                Android category header). Mirrors disabled_groups
+                semantically — the same conceptual entity (android
+                feature surface) but the credential catalogue uses its
+                own category taxonomy independent of node groups.
+            disabled_skill_folders: list[str]
+                Absolute blocklist for the Master Skill folder
+                dropdown — every entry hides the matching subfolder
+                under server/skills/. Use when disabling a feature
+                that also ships its own skill folder (e.g.
+                'android_agent' so users can't see the 12 android-
+                tied skills when android nodes are disabled).
+                Email has no dedicated skill folder (email-tied skills
+                live under productivity_agent mixed with Google
+                Workspace) so no email entry is needed.
         """
+        defaults = {
+            "show_all": True,
+            "enabled_nodes": [],
+            "disabled_groups": [],
+            "disabled_nodes": [],
+            "disabled_credential_categories": [],
+            "disabled_skill_folders": [],
+        }
+
         if not self._config_path.exists():
-            return {"show_all": True, "enabled_nodes": []}
+            return defaults
 
         try:
             with self._config_path.open("r", encoding="utf-8") as f:
                 raw = json.load(f)
         except Exception as e:
             logger.warning("Failed to parse node_allowlist.json, falling back to show_all: %s", e)
-            return {"show_all": True, "enabled_nodes": []}
-
-        enabled_nodes = raw.get("enabled_nodes", [])
-        if not isinstance(enabled_nodes, list):
-            logger.warning("node_allowlist.json 'enabled_nodes' is not a list, falling back to show_all")
-            return {"show_all": True, "enabled_nodes": []}
-
-        enabled_nodes = [n for n in enabled_nodes if isinstance(n, str)]
-
-        if len(enabled_nodes) == 0:
-            return {"show_all": True, "enabled_nodes": []}
-
-        return {"show_all": False, "enabled_nodes": enabled_nodes}
+            return defaults
+
+        def _str_list(key: str) -> List[str]:
+            value = raw.get(key, [])
+            if not isinstance(value, list):
+                logger.warning(
+                    "node_allowlist.json '%s' is not a list, treating as empty",
+                    key,
+                )
+                return []
+            return [n for n in value if isinstance(n, str)]
+
+        enabled_nodes = _str_list("enabled_nodes")
+        disabled_groups = _str_list("disabled_groups")
+        disabled_nodes = _str_list("disabled_nodes")
+        disabled_credential_categories = _str_list("disabled_credential_categories")
+        disabled_skill_folders = _str_list("disabled_skill_folders")
+
+        show_all = len(enabled_nodes) == 0
+
+        return {
+            "show_all": show_all,
+            "enabled_nodes": enabled_nodes,
+            "disabled_groups": disabled_groups,
+            "disabled_nodes": disabled_nodes,
+            "disabled_credential_categories": disabled_credential_categories,
+            "disabled_skill_folders": disabled_skill_folders,
+        }
 
 
 _instance: NodeAllowlistService | None = None

package/server/services/node_executor.py

@@ -33,9 +33,9 @@ if TYPE_CHECKING:
     from core.config import Settings
     from core.database import Database
     from services.ai import AIService
-    from services.maps import MapsService
+    from nodes.location._service import MapsService
     from services.text import TextService
-    from services.android_service import AndroidService
+    from nodes.android._dispatcher import AndroidService
 
 logger = get_logger(__name__)
 

package/server/services/node_output_schemas.py

@@ -866,6 +866,26 @@ def list_node_types_with_schema() -> list[str]:
     return sorted(NODE_OUTPUT_SCHEMAS.keys())
 
 
+from services.plugin.registry import IdempotentRegistry as _IdempotentRegistry  # noqa: E402
+
+
+def _bust_schema_cache(node_type: str, _model_class: type[BaseModel]) -> None:
+    """on_register hook: drop the cached JSON schema for the re-registered type."""
+    _schema_cache.pop(node_type, None)
+
+
+# Backed by the module-level NODE_OUTPUT_SCHEMAS dict so existing
+# readers (e.g. get_output_schema, list_node_types_with_schema, tests)
+# keep working.
+_OUTPUT_SCHEMA_REGISTRY: _IdempotentRegistry[str, type[BaseModel]] = (
+    _IdempotentRegistry(
+        "output_schema",
+        items=NODE_OUTPUT_SCHEMAS,
+        on_register=_bust_schema_cache,
+    )
+)
+
+
 def register_output_schema(node_type: str, model_class: type[BaseModel]) -> None:
     """Publish an output schema for a node type from a plugin package.
 
@@ -877,13 +897,4 @@ def register_output_schema(node_type: str, model_class: type[BaseModel]) -> None
 
     See e.g. ``nodes/telegram/__init__.py``.
     """
-    existing = NODE_OUTPUT_SCHEMAS.get(node_type)
-    if existing is not None and existing is not model_class:
-        raise ValueError(
-            f"Output schema for '{node_type}' is already registered as "
-            f"{existing.__module__}.{existing.__qualname__}; refusing to "
-            f"overwrite with {model_class.__module__}.{model_class.__qualname__}"
-        )
-    NODE_OUTPUT_SCHEMAS[node_type] = model_class
-    # Bust the JSON-schema cache so the next call re-serialises.
-    _schema_cache.pop(node_type, None)
+    _OUTPUT_SCHEMA_REGISTRY.register(node_type, model_class)

package/server/services/node_spec.py

@@ -85,7 +85,7 @@ def get_node_spec(node_type: str) -> Optional[dict[str, Any]]:
     # Wave 10.A — full visual contract. Only emit fields when seeded so the
     # wire format stays compact and unseeded types keep the pre-10 shape.
     for key in ("color", "componentKind", "handles", "credentials",
-                "hideOutputHandle", "visibility"):
+                "hideOutputHandle", "hideInputHandle", "visibility"):
         if key in meta:
             spec[key] = meta[key]
 

package/server/services/oauth_utils.py

@@ -11,7 +11,7 @@ base URL (scheme + host + port) comes from the connection itself.
 
 from urllib.parse import urlparse
 
-from services.google_oauth import get_callback_paths
+from nodes.google._oauth import get_callback_paths
 
 
 def get_base_url(connection) -> str:

package/server/services/plugin/__init__.py

@@ -28,6 +28,7 @@ from __future__ import annotations
 from services.plugin.base import BaseNode, NodeUserError
 from services.plugin.action import ActionNode
 from services.plugin.trigger import TriggerNode
+from services.plugin.polling import PollingTriggerNode
 from services.plugin.tool import ToolNode
 from services.plugin.operation import Operation, OperationSpec
 from services.plugin.routing import Routing, RoutingRequest, RoutingOutput, execute_routing
@@ -52,6 +53,7 @@ __all__ = [
     "NodeUserError",
     "ActionNode",
     "TriggerNode",
+    "PollingTriggerNode",
     "ToolNode",
     "Operation",
     "OperationSpec",