machinaos 0.0.76 → 0.0.78

package/server/services/plugin/base.py

@@ -63,6 +63,22 @@ class _EmptyOutput(BaseModel):
     pass
 
 
+# Group memberships that mark a node as auxiliary configuration —
+# its panel inherits the parent's main inputs instead of showing
+# direct inputs. Centralized here so the frontend doesn't need to
+# know any group strings.
+_CONFIG_NODE_GROUPS = frozenset({"memory", "tool"})
+
+
+def _derive_auto_ui_hints(group: Sequence[str]) -> Dict[str, Any]:
+    """Auto-derived uiHints based on group membership. Plugin-declared
+    ``ui_hints`` override these — explicit always wins."""
+    hints: Dict[str, Any] = {}
+    if any(g in _CONFIG_NODE_GROUPS for g in group):
+        hints["isConfigNode"] = True
+    return hints
+
+
 class BaseNode:
     """Abstract plugin node. Do not instantiate directly — subclass
     :class:`ActionNode`, :class:`TriggerNode`, or :class:`ToolNode`.
@@ -111,6 +127,7 @@ class BaseNode:
     handles: ClassVar[Sequence[Dict[str, Any]]] = ()
     visibility: ClassVar[str] = "all"
     hide_output_handle: ClassVar[bool] = False
+    hide_input_handle: ClassVar[bool] = False
     ui_hints: ClassVar[Dict[str, Any]] = {}
     annotations: ClassVar[Dict[str, Any]] = {}
 
@@ -140,6 +157,27 @@ class BaseNode:
         cls._operations = collect_operations(cls)
         if abstract or not cls.type:
             return
+        # Auto-hide default canvas input/output handles for nodes whose
+        # primary surface area is the LLM-tool call path. Two cases:
+        #   * Pure ToolNodes (component_kind="tool" -- calculator,
+        #     duckduckgoSearch, writeTodos, agentBuilder, ...). They
+        #     wire through their own output-tool handle; the hardcoded
+        #     SquareNode input-main + output-main are visual clutter.
+        #   * Dual-purpose ActionNodes with usable_as_tool=True (gmail,
+        #     twitter*, brave_search, all 16 android nodes via cascade,
+        #     code executors via cascade, ...). Same reasoning: the
+        #     LLM-tool path is the dominant use; default handles confuse
+        #     the canvas.
+        # Subclasses opt out by explicitly setting either flag to False
+        # on the class.
+        is_tool_oriented = (
+            cls.usable_as_tool or cls.component_kind == "tool"
+        )
+        if is_tool_oriented:
+            if "hide_input_handle" not in cls.__dict__:
+                cls.hide_input_handle = True
+            if "hide_output_handle" not in cls.__dict__:
+                cls.hide_output_handle = True
         # Eager registry write — same four registries as @register_node.
         from services.node_registry import register_node, register_node_class
         register_node(
@@ -185,10 +223,14 @@ class BaseNode:
             meta["credentials"] = [c.id for c in cls.credentials]
         if cls.hide_output_handle:
             meta["hideOutputHandle"] = True
+        if cls.hide_input_handle:
+            meta["hideInputHandle"] = True
         if cls.visibility != "all":
             meta["visibility"] = cls.visibility
-        if cls.ui_hints:
-            meta["uiHints"] = dict(cls.ui_hints)
+        ui_hints = _derive_auto_ui_hints(cls.group)
+        ui_hints.update(cls.ui_hints)
+        if ui_hints:
+            meta["uiHints"] = ui_hints
         return meta
 
     # ---- legacy handler adapter ------------------------------------------

package/server/services/plugin/credential.py

@@ -13,16 +13,134 @@ Two concrete bases:
 
 Both are discovered at import time via :data:`CREDENTIAL_REGISTRY`
 (populated by ``__init_subclass__``). Nothing else needs to wire them.
+
+Validation is also a base-class concern. Every "validate this key"
+flow shares the same wiring (read api_key + session_id from request,
+call provider probe, store on success, broadcast status, return
+envelope). Only the probe itself varies. That common scaffold lives on
+:meth:`Credential.validate`; subclasses override the lighter
+:meth:`Credential._probe` to supply the per-provider call. See
+:class:`ProbeResult` for the typed return shape.
 """
 
 from __future__ import annotations
 
-from typing import Any, ClassVar, Dict, Literal, Optional, Sequence
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Any, ClassVar, Dict, List, Literal, Optional, Sequence
+
+import httpx
+
+logger = logging.getLogger(__name__)
 
 
 CREDENTIAL_REGISTRY: Dict[str, type] = {}
 
 
+@dataclass
+class ProbeResult:
+    """Outcome of a per-provider validation probe.
+
+    Carries the common ``valid`` / ``message`` flags every validator
+    returns, plus optional fields a few providers extend with
+    (``models`` for LLM ``/v1/models`` lists, ``model_params`` for
+    Ollama / LM Studio per-model context, ``extra`` for
+    provider-specific extensions like Apify's ``username`` / ``email``
+    / ``plan``). The base ``Credential.validate`` reads these fields
+    when wiring storage / broadcast / response envelope so subclasses
+    don't repeat any of that scaffolding.
+    """
+
+    valid: bool
+    message: str = ""
+    models: List[str] = field(default_factory=list)
+    model_params: Optional[Dict[str, Dict[str, Any]]] = None
+    # Free-form passthrough fields for provider-specific extensions
+    # (Apify returns username / email / plan; Twitter returns user id;
+    # Maps returns nothing). Merged into the response envelope.
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+
+def classify_credential_error(
+    exc: BaseException, *, display_name: str
+) -> ProbeResult:
+    """Map a transport / SDK exception to a typed ``ProbeResult``.
+
+    Single source of truth for credential-error → user-message mapping.
+    Used by the base ``Credential.validate`` after a ``_probe`` call
+    raises, and by the local-LLM probe directly. Catches the documented
+    ``httpx`` / ``openai`` exception hierarchy so operator logs see
+    "HTTP 401" / "connect-refused" / "timeout" instead of an opaque
+    repr.
+
+    Returns a ``ProbeResult(valid=False, message=...)`` carrying the
+    user-facing string. Operator logs are emitted at WARN by the
+    caller — this helper just classifies, doesn't log.
+    """
+    import openai  # local import: openai is a heavy SDK
+
+    if isinstance(exc, httpx.TimeoutException) or isinstance(exc, openai.APITimeoutError):
+        return ProbeResult(
+            valid=False,
+            message=f"Request to {display_name} timed out — try again or check the network.",
+        )
+
+    if isinstance(exc, httpx.ConnectError) or isinstance(exc, openai.APIConnectionError):
+        return ProbeResult(
+            valid=False,
+            message=f"Could not reach {display_name}. Is the server running?",
+        )
+
+    if isinstance(exc, httpx.HTTPStatusError):
+        status = exc.response.status_code
+        return _classify_status(status, display_name)
+
+    if isinstance(exc, openai.AuthenticationError):
+        return _classify_status(401, display_name)
+    if isinstance(exc, openai.PermissionDeniedError):
+        return _classify_status(403, display_name)
+    if isinstance(exc, openai.NotFoundError):
+        return _classify_status(404, display_name)
+    if isinstance(exc, openai.RateLimitError):
+        return _classify_status(429, display_name)
+    if isinstance(exc, openai.APIStatusError):
+        status = getattr(getattr(exc, "response", None), "status_code", 500)
+        return _classify_status(status, display_name)
+
+    # Unknown exception: surface the type name so the operator log line
+    # is still useful, but don't dump a stacktrace into the user's toast.
+    return ProbeResult(
+        valid=False,
+        message=f"Could not validate {display_name}: {type(exc).__name__}: {exc}",
+    )
+
+
+def _classify_status(status: int, display_name: str) -> ProbeResult:
+    """Map an HTTP status code to a user-facing message."""
+    if status in (401, 403):
+        return ProbeResult(valid=False, message=f"{display_name} rejected the API key.")
+    if status == 404:
+        return ProbeResult(
+            valid=False,
+            message=f"{display_name} returned 404 — endpoint not found. Check the URL.",
+        )
+    if status == 429:
+        return ProbeResult(
+            valid=False,
+            message=f"{display_name} rate-limited the request — try again shortly.",
+        )
+    if 500 <= status < 600:
+        return ProbeResult(
+            valid=False,
+            message=f"{display_name} returned HTTP {status} — try again later.",
+        )
+    return ProbeResult(
+        valid=False,
+        message=f"{display_name} returned HTTP {status}.",
+    )
+
+
 class Credential:
     """Base class for provider credentials.
 
@@ -73,6 +191,105 @@ class Credential:
         """
         return request
 
+    # ---- Validation -------------------------------------------------
+    #
+    # Every "validate this credential" flow follows the same wiring:
+    # read api_key + session_id from the request, run a per-provider
+    # probe, store on success, broadcast status, return the standard
+    # response envelope. Only the probe call genuinely varies — so the
+    # scaffolding lives on the base and subclasses override the lighter
+    # :meth:`_probe` hook. The dispatch entry point (called by the WS
+    # router) is :meth:`validate`; subclasses with non-standard
+    # side-effect ordering (e.g. local-LLM credentials store under TWO
+    # keys) override :meth:`validate` directly.
+
+    @classmethod
+    async def validate(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Run the credential validation probe and wire side effects.
+
+        The shared scaffold:
+          1. Read ``api_key`` + ``session_id`` from the request data.
+          2. Guard: missing key → fast-fail envelope.
+          3. Call :meth:`_probe` (subclass-supplied; provider-specific).
+          4. On exception, classify via :func:`classify_credential_error`.
+          5. On valid result, persist via ``auth_service.store_api_key``.
+          6. Broadcast the new status via
+             ``StatusBroadcaster.update_api_key_status`` (always — invalid
+             results clear stale state on connected clients).
+          7. Return the standard response envelope.
+
+        Subclasses with non-standard storage / broadcast (e.g. local-LLM
+        credentials that store both URL and placeholder key) override
+        this method directly.
+        """
+        from core.container import container
+        from services.status_broadcaster import get_status_broadcaster
+
+        api_key = (data.get("api_key") or "").strip()
+        session_id = data.get("session_id", "default")
+        if not api_key:
+            return {
+                "success": False,
+                "valid": False,
+                "error": f"{cls.id} api_key required",
+            }
+
+        try:
+            result = await cls._probe(api_key)
+        except Exception as exc:  # noqa: BLE001 — classified below
+            display = cls.display_name or cls.id
+            result = classify_credential_error(exc, display_name=display)
+            logger.warning(
+                "[%s] credential probe failed: %s",
+                cls.id,
+                result.message,
+            )
+
+        broadcaster = get_status_broadcaster()
+        auth_service = container.auth_service()
+
+        if result.valid:
+            await auth_service.store_api_key(
+                provider=cls.id,
+                api_key=api_key,
+                models=result.models,
+                session_id=session_id,
+                model_params=result.model_params,
+            )
+
+        await broadcaster.update_api_key_status(
+            provider=cls.id,
+            valid=result.valid,
+            message=result.message,
+            has_key=result.valid,
+            models=result.models,
+        )
+
+        return {
+            "success": True,
+            "provider": cls.id,
+            "valid": result.valid,
+            "message": result.message,
+            "models": result.models,
+            "timestamp": time.time(),
+            **result.extra,
+        }
+
+    @classmethod
+    async def _probe(cls, api_key: str) -> ProbeResult:
+        """Run the per-provider validation probe.
+
+        Subclass override point — the probe MUST NOT do storage,
+        broadcasts, or registry mutation. It returns a
+        :class:`ProbeResult` describing what the upstream returned;
+        :meth:`validate` does the rest. Raise ``httpx.*`` /
+        ``openai.OpenAIError`` to let the base map them to a typed
+        message via :func:`classify_credential_error`.
+        """
+        raise NotImplementedError(
+            f"Credential subclass {cls.__name__} must override _probe()"
+        )
+
 
 class OAuth2Credential(Credential):
     """OAuth 2.0 with refresh-token support.
@@ -130,6 +347,15 @@ class ApiKeyCredential(Credential):
             category = "Search"
             key_name = "X-Subscription-Token"
             key_location = "header"
+            probe_url = "https://api.search.brave.com/res/v1/web/search"
+            probe_params = {"q": "ping", "count": 1}
+
+    Subclasses get a default :meth:`_probe` for free as long as they
+    declare a ``probe_url``. Auth attaches via :meth:`inject` (header /
+    query / bearer). Subclasses with bespoke validation (URL with
+    embedded token, SDK-based probe, custom 200-with-error envelope)
+    override :meth:`_probe` directly — see ``TelegramCredential``,
+    ``GoogleMapsCredential``, ``ApifyCredential``.
     """
 
     auth: ClassVar[Literal["api_key"]] = "api_key"
@@ -139,6 +365,20 @@ class ApiKeyCredential(Credential):
     # Extra fields stored alongside (e.g. "apify_account_id" for Apify)
     extra_fields: ClassVar[Sequence[str]] = ()
 
+    # ---- Declarative HTTP probe ------------------------------------
+    #
+    # The default :meth:`_probe` builds a request from these attributes,
+    # runs it through :meth:`inject` to attach the key, sends via httpx,
+    # and calls :meth:`_handle_probe_response` on a 2xx response.
+    # ``httpx.HTTPStatusError`` / ``TimeoutException`` / ``ConnectError``
+    # propagate to :meth:`Credential.validate`, where
+    # :func:`classify_credential_error` produces the user-facing message.
+    probe_url: ClassVar[str] = ""             # set to enable the default probe
+    probe_method: ClassVar[str] = "GET"
+    probe_params: ClassVar[Dict[str, Any]] = {}
+    probe_json: ClassVar[Optional[Dict[str, Any]]] = None
+    probe_timeout_seconds: ClassVar[float] = 10.0
+
     @classmethod
     async def resolve(cls, *, user_id: str = "owner") -> Dict[str, Any]:
         from core.container import container
@@ -173,3 +413,50 @@ class ApiKeyCredential(Credential):
             qs[name] = api_key
             request = {**request, "params": qs}
         return request
+
+    @classmethod
+    async def _probe(cls, api_key: str) -> ProbeResult:
+        """Default declarative HTTP probe.
+
+        Subclasses set ``probe_url`` (and optionally ``probe_method``,
+        ``probe_params``, ``probe_json``); auth attaches via
+        :meth:`inject`. Override :meth:`_handle_probe_response` to
+        extract provider-specific metadata or detect API-level failures
+        embedded in a 2xx response (e.g. Telegram's ``{ok: false}``
+        envelope, Maps' ``status: REQUEST_DENIED``).
+        """
+        if not cls.probe_url:
+            raise NotImplementedError(
+                f"Credential subclass {cls.__name__} must override _probe() "
+                f"or set the `probe_url` class attribute"
+            )
+
+        request = cls.inject(
+            {"api_key": api_key},
+            {"headers": {}, "params": dict(cls.probe_params)},
+        )
+
+        async with httpx.AsyncClient(timeout=cls.probe_timeout_seconds) as client:
+            response = await client.request(
+                cls.probe_method,
+                cls.probe_url,
+                headers=request.get("headers") or None,
+                params=request.get("params") or None,
+                json=cls.probe_json,
+            )
+        response.raise_for_status()
+        return cls._handle_probe_response(response)
+
+    @classmethod
+    def _handle_probe_response(cls, response: httpx.Response) -> ProbeResult:
+        """Translate a 2xx probe response to a :class:`ProbeResult`.
+
+        Default: success message only. Override to inspect the body —
+        for example to surface bot identity (Telegram ``getMe``) or to
+        catch wrapped failures that arrive as 200s (Telegram
+        ``{ok: false}``).
+        """
+        return ProbeResult(
+            valid=True,
+            message=f"{cls.display_name or cls.id} API key is valid",
+        )

package/server/services/plugin/deps.py

@@ -0,0 +1,105 @@
+"""Lazy dependency-injection helpers (Wave 11.I, milestone T-residual).
+
+Plugin packages need lazy imports of singletons from
+:mod:`core.container` to avoid the
+``nodes/<plugin>/__init__ -> core.container -> nodes.android._dispatcher
+-> nodes.android.__init__ -> _router`` import cycle that bites at
+package load time. Pre-T-residual the codebase had 53 inline
+``from core.container import container`` statements scattered across
+plugin handlers + services. These helpers consolidate the pattern
+into one place.
+
+**Important: NOT memoised.** Both helpers re-resolve the singleton on
+every call. Test fixtures swap the auth-service / database instances
+mid-test via the dependency-injection container's ``override``
+mechanism; a memoised cache would lock in the originally-resolved
+instance and the override would be silently ignored. The lookup is
+a dict access -- caching adds nothing measurable.
+
+Usage::
+
+    from services.plugin.deps import get_auth_service
+
+    async def handle_thing(data, websocket):
+        auth_service = get_auth_service()
+        client_id = await auth_service.get_api_key("twitter_client_id")
+        ...
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from core.cache import CacheService
+    from core.database import Database
+    from services.ai import AIService
+    from services.auth import AuthService
+
+
+def get_auth_service() -> "AuthService":
+    """Resolve the singleton :class:`services.auth.AuthService`.
+
+    Lazy import + call-time lookup. Test monkeypatching depends on
+    the container override being read at call time, not at module
+    import time -- do NOT memoise.
+    """
+    from core.container import container
+
+    return container.auth_service()
+
+
+def get_database() -> "Database":
+    """Resolve the singleton :class:`core.database.Database`.
+
+    Same NOT-memoised contract as :func:`get_auth_service`.
+    """
+    from core.container import container
+
+    return container.database()
+
+
+def get_cache() -> "CacheService":
+    """Resolve the singleton :class:`core.cache.CacheService`."""
+    from core.container import container
+
+    return container.cache()
+
+
+def get_ai_service() -> "AIService":
+    """Resolve the singleton :class:`services.ai.AIService`."""
+    from core.container import container
+
+    return container.ai_service()
+
+
+def get_text_service() -> Any:
+    """Resolve the singleton ``TextService`` (text generation)."""
+    from core.container import container
+
+    return container.text_service()
+
+
+def get_maps_service() -> Any:
+    """Resolve the singleton :class:`nodes.location._service.MapsService`."""
+    from core.container import container
+
+    return container.maps_service()
+
+
+def get_android_service() -> Any:
+    """Resolve the singleton :class:`nodes.android._dispatcher.AndroidService`."""
+    from core.container import container
+
+    return container.android_service()
+
+
+__all__ = [
+    "get_auth_service",
+    "get_database",
+    "get_cache",
+    "get_ai_service",
+    "get_text_service",
+    "get_maps_service",
+    "get_android_service",
+]

package/server/services/plugin/edge_walker.py

@@ -168,11 +168,19 @@ async def _build_memory_entry(
         ),
         "long_term_enabled": memory_params.get("long_term_enabled", False),
         "retrieval_count": int(memory_params.get("retrieval_count", 3)),
+        # Claude Code CLI session continuity: the UUID claude returned on
+        # the previous successful run. claude_code_agent passes this as
+        # `--resume <UUID>` so claude finds its own JSONL transcript at
+        # `<CLAUDE_CONFIG_DIR>/projects/<cwd-encoded>/<UUID>.jsonl`.
+        "last_session_id": memory_params.get("last_session_id"),
     }
-    logger.debug(
-        f"{log_prefix} Connected memory node: session={session_id} "
-        f"(auto={not configured_session or configured_session == 'default'}), "
-        f"content_length={len(entry['memory_content'])}"
+    logger.info(
+        "%s Connected memory node: node=%s session=%s (auto=%s) "
+        "content_length=%d last_session_id=%s",
+        log_prefix, memory_node_id, session_id,
+        not configured_session or configured_session == "default",
+        len(entry["memory_content"]),
+        entry["last_session_id"],
     )
     return entry