machinaos 0.0.76 → 0.0.78

package/server/services/ai.py

@@ -41,6 +41,15 @@ import operator
 from langchain_core.messages import BaseMessage  # eager: needed for AgentState type resolution
 import json
 
+# Eager imports — both are tiny and read on every chat/agent execution
+# path. ``openai`` is the canonical SDK whose typed exception hierarchy
+# (``BadRequestError`` / ``AuthenticationError`` / ``RateLimitError`` / …)
+# is the contract this module dispatches on; ``NodeUserError`` is the
+# framework's "user-correctable, no-traceback" sentinel used to surface
+# those typed errors cleanly through ``BaseNode.execute()``.
+import openai
+from services.plugin import NodeUserError
+
 if TYPE_CHECKING:
     from langchain_openai import ChatOpenAI  # noqa: F401
     from langchain_core.messages import HumanMessage, SystemMessage, AIMessage, ToolMessage  # noqa: F401
@@ -456,9 +465,24 @@ def detect_provider_from_model(model: str) -> str:
 
 
 def is_model_valid_for_provider(model: str, provider: str) -> bool:
-    """Check if model name matches the provider's patterns."""
-    # OpenRouter is a proxy supporting all models (provider/model format) - always valid
-    if provider == 'openrouter':
+    """Check if model name matches the provider's patterns.
+
+    Pattern-matching is meaningful for cloud providers — `gpt-*` is OpenAI,
+    `claude-*` is Anthropic, etc. — and the check guards against picking
+    a model from one provider's dropdown after switching to another.
+
+    For "open-world" providers (OpenRouter proxy, local Ollama / LM Studio
+    servers) the model namespace is whatever the user has installed:
+    `llama-3.2`, `qwen2.5-coder`, `phi-3-mini`, custom GGUF files, etc.
+    None of those contain the literal substrings `ollama` or `lmstudio`,
+    so applying the cloud-style filter produces a false negative on every
+    valid local model — the call site then "uses default" which for a
+    local provider is the SAME model name, emitting a confusing
+    "invalid ... using default: <same name>" log line. Treat all three
+    as always-valid; the local-server SDK will reject genuinely missing
+    models at request time with a clear 404.
+    """
+    if provider in ('openrouter', 'ollama', 'lmstudio'):
         return True
     config = get_provider_configs().get(provider)
     if not config:
@@ -1397,11 +1421,16 @@ class AIService:
         """Fetch available models from provider API.
 
         Native providers use their SDK-based fetch_models(). Groq/Cerebras
-        fall back to the LangChain httpx path.
+        fall back to the LangChain httpx path. Local providers (ollama,
+        lmstudio) honour the user's stored ``{provider}_proxy`` base URL
+        the same way ``execute_chat`` does — without this passthrough the
+        probe always hits the JSON default and never sees the user's
+        actual installed models.
         """
         # --- Native SDK path ---
         if is_native_provider(provider):
-            native_provider = create_provider(provider, api_key)
+            proxy_url = await self.auth.get_api_key(f"{provider}_proxy")
+            native_provider = create_provider(provider, api_key, proxy_url=proxy_url)
             return await native_provider.fetch_models(api_key)
 
         # --- LangChain fallback (groq, cerebras) ---
@@ -1435,10 +1464,14 @@ class AIService:
         except Exception as e:
             logger.warning(f"[AI] Failed to fetch models from {provider} API: {e}")
 
-        # Fallback to curated list from llm_defaults.json
+        # Fallback to curated list from llm_defaults.json. When the
+        # provider has no default_model declared (intentional for local
+        # servers like ollama/lmstudio), return an empty list so the
+        # frontend dropdown shows a real "no models" empty state instead
+        # of a placeholder name the user doesn't actually have.
         if curated:
             return curated
-        return [config.default_model]
+        return [config.default_model] if config.default_model else []
 
     async def execute_chat(self, node_id: str, node_type: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
         """Execute AI chat model."""
@@ -1581,6 +1614,16 @@ class AIService:
                 "execution_time": time.time() - start_time
             }
 
+        except openai.OpenAIError as e:
+            # Typed openai SDK exception — context overflow (BadRequestError),
+            # bad key (AuthenticationError), missing model (NotFoundError),
+            # server unreachable (APIConnectionError), etc. All
+            # user-correctable. Propagate as NodeUserError so BaseNode.execute()
+            # logs at WARN with no traceback.
+            log_api_call(logger, provider if 'provider' in locals() else 'unknown',
+                        model if 'model' in locals() else 'unknown', "chat", False, error=str(e))
+            raise NodeUserError(str(e)) from e
+
         except Exception as e:
             logger.error("AI execution failed", node_id=node_id, error=str(e))
             log_api_call(logger, provider if 'provider' in locals() else 'unknown',
@@ -1927,6 +1970,18 @@ class AIService:
                     stream_mode="values",
                 ):
                     final_state = snapshot
+                    # Per-step iteration broadcast (CloudEvents envelope
+                    # via broadcast_agent_progress -> wire key
+                    # `agent_progress`). The FE updates nodeStatusStore
+                    # so the AI agent body shows live "iteration / max".
+                    if broadcaster:
+                        iter_count = snapshot.get("iteration", 0) if isinstance(snapshot, dict) else 0
+                        await broadcaster.broadcast_agent_progress(
+                            node_id,
+                            workflow_id=workflow_id,
+                            iteration=iter_count,
+                            max_iterations=recursion_limit,
+                        )
             except GraphRecursionError:
                 # Append a terminal AIMessage so downstream extraction (and
                 # the post-loop _track_token_usage / compact_context call)
@@ -2060,6 +2115,13 @@ class AIService:
                 "execution_time": time.time() - start_time
             }
 
+        except openai.OpenAIError as e:
+            # See execute_chat for the rationale — typed SDK errors are
+            # user-correctable and re-raised as NodeUserError so BaseNode
+            # logs at WARN without a traceback.
+            log_api_call(logger, provider, model, "agent", False, error=str(e))
+            raise NodeUserError(str(e)) from e
+
         except Exception as e:
             logger.error("[LangGraph] AI agent execution failed", node_id=node_id, error=str(e))
             log_api_call(logger, provider, model, "agent", False, error=str(e))
@@ -2361,6 +2423,16 @@ class AIService:
                         stream_mode="values",
                     ):
                         final_state = snapshot
+                        # Per-step iteration broadcast — see execute_agent
+                        # for the rationale.
+                        if broadcaster:
+                            iter_count = snapshot.get("iteration", 0) if isinstance(snapshot, dict) else 0
+                            await broadcaster.broadcast_agent_progress(
+                                node_id,
+                                workflow_id=workflow_id,
+                                iteration=iter_count,
+                                max_iterations=recursion_limit,
+                            )
                 except GraphRecursionError:
                     msgs = list((final_state or {}).get("messages") or [])
                     msgs.append(AIMessage(content=(
@@ -2516,6 +2588,11 @@ class AIService:
                 "execution_time": time.time() - start_time
             }
 
+        except openai.OpenAIError as e:
+            # Typed SDK error — see execute_chat for rationale.
+            log_api_call(logger, provider, model, "chat_agent", False, error=str(e))
+            raise NodeUserError(str(e)) from e
+
         except Exception as e:
             logger.error("[ChatAgent] Execution failed", node_id=node_id, error=str(e))
             log_api_call(logger, provider, model, "chat_agent", False, error=str(e))
@@ -2623,6 +2700,8 @@ class AIService:
             # Email (Himalaya CLI, dual-purpose tools)
             'emailSend': 'email_send',
             'emailRead': 'email_read',
+            # Stripe (CLI pass-through, dual-purpose tool)
+            'stripeAction': 'stripe_action',
         }
         DEFAULT_TOOL_DESCRIPTIONS = {
             'calculatorTool': 'Perform mathematical calculations. Operations: add, subtract, multiply, divide, power, sqrt, mod, abs',
@@ -2703,6 +2782,8 @@ class AIService:
             # Email (Himalaya CLI, dual-purpose tools)
             'emailSend': 'Send email via SMTP. Specify to, subject, body. Optional: cc, bcc, body_type (text/html).',
             'emailRead': 'Read and manage emails via IMAP. Operations: list (envelopes), search (query), read (message by ID), folders (list), move, delete, flag.',
+            # Stripe (CLI pass-through, dual-purpose tool)
+            'stripeAction': "Run any Stripe CLI command and return the parsed JSON response. Pass a 'command' field exactly as you would type after 'stripe ' (e.g. 'customers create --email a@b.com', 'charges list --limit 10', 'payment_intents create --amount 2000 --currency usd', 'refunds create --payment-intent pi_xxx', 'trigger charge.succeeded'). Covers every Stripe resource: customers, charges, payment_intents, refunds, invoices, products, prices, subscriptions, payment_methods, setup_intents, transfers, payouts, plus 'trigger <event>' for synthetic test events.",
         }
 
         try:
@@ -2896,7 +2977,7 @@ class AIService:
                     )
                 return EmptyAndroidSchema
 
-            from services.android_service import SERVICE_ACTIONS
+            from nodes.android._dispatcher import SERVICE_ACTIONS
 
             service_info = []
             for svc in connected_services:

package/server/services/auth.py

@@ -1,8 +1,32 @@
-"""API key management service with encrypted credentials database."""
+"""API key management service with encrypted credentials database.
+
+Source of truth: ``CredentialsDatabase`` (encrypted SQLite at credentials.db).
+Two derived in-memory caches exist for performance — both keyed by composite
+strings, both invalidated atomically on every DB write/delete:
+
+- ``_api_key_cache``: ``Dict[str, ApiKeyCacheEntry]`` keyed by ``{session}_{provider}``.
+  One entry carries decrypted key + models + stored_at. Replaces the previous
+  pair of ``_memory_cache`` (key) + ``_models_cache`` (models) which shared the
+  same key shape but had separate write/evict sites — invitation to drift.
+- ``_oauth_cache``: ``Dict[str, Dict]`` keyed by ``{customer}_{provider}``.
+  Different namespace, different shape, different lifecycle — kept separate.
+  Per RFC 9700 (OAuth 2.0 BCP 2024) refresh tokens are NOT cached here;
+  ``get_oauth_refresh_token()`` reads from the DB on every call.
+
+Async-safety: every read / write is await-free across the cache check, so
+the GIL guarantees atomicity at the bytecode level — no locks needed. Lazy
+DB fallback inside ``get_api_key`` introduces an await, but the only race
+is "two concurrent reads both miss cache and both fetch from DB" — benign,
+since both writes set the same value.
+
+Neither cache has a TTL today; eviction is on explicit ``remove_*`` or
+``clear_cache()`` (logout). External revocation by an upstream provider is
+not detected.
+"""
 
 import hashlib
-import json
-from pathlib import Path
+import time
+from dataclasses import dataclass, field
 from typing import Dict, Any, Optional, List
 
 from core.config import Settings
@@ -14,6 +38,20 @@ from core.logging import get_logger
 logger = get_logger(__name__)
 
 
+@dataclass
+class ApiKeyCacheEntry:
+    """One in-memory cache entry per ``{session}_{provider}``.
+
+    Carries the decrypted API key, the models list discovered at validation
+    time, and a monotonic timestamp for future TTL support. Single struct
+    so the two values can never drift — one write site, one evict site.
+    """
+
+    key: str
+    models: List[str] = field(default_factory=list)
+    stored_at: float = field(default_factory=time.monotonic)
+
+
 class AuthService:
     """API key management service using encrypted credentials database.
 
@@ -32,23 +70,51 @@ class AuthService:
         self.cache = cache  # Kept for backward compatibility, not used for API keys
         self.database = database  # Kept for backward compatibility
         self.settings = settings
-        # Memory-only cache for decrypted API keys (never persisted to Redis/disk)
-        self._memory_cache: Dict[str, str] = {}
-        # Memory-only cache for models list
-        self._models_cache: Dict[str, List[str]] = {}
-        # Memory-only cache for OAuth tokens
+        # Memory-only cache for decrypted API keys + models (never persisted
+        # to Redis/disk). Single entry per provider; one write site, one
+        # evict site — see module docstring.
+        self._api_key_cache: Dict[str, ApiKeyCacheEntry] = {}
+        # Memory-only cache for OAuth tokens. Different key namespace
+        # (``{customer}_{provider}``); kept separate from API keys.
+        # Per RFC 9700 the refresh_token is NOT cached here — only
+        # access_token + display fields. Refresh-token access goes via
+        # ``get_oauth_refresh_token()`` which reads from the DB.
         self._oauth_cache: Dict[str, Dict[str, Any]] = {}
 
     def hash_api_key(self, api_key: str) -> str:
         """Create hash for API key identification."""
         return hashlib.sha256(api_key.encode()).hexdigest()[:16]
 
+    def _bump_catalogue_version(self) -> None:
+        """Notify the credential registry that a credential has changed.
+
+        Bumps the registry's mutation counter so the next call to
+        ``CredentialRegistry.get_version()`` returns a new content hash.
+        The frontend's conditional ``since: <prior version>`` fetch then
+        receives a fresh catalogue with updated ``stored`` flags
+        instead of ``{unchanged: true}``. Without this bump, the version
+        is constant for the life of the process and the per-provider
+        ``stored`` flag stays stale on every connected client until the
+        process restarts.
+
+        Local import to avoid an import cycle at module load time.
+        Failures are swallowed (logged at WARNING) so a missing registry
+        never blocks a credential mutation from completing.
+        """
+        try:
+            from services.credential_registry import get_credential_registry
+
+            get_credential_registry().invalidate_version()
+        except Exception as e:  # noqa: BLE001 — best-effort signal
+            logger.warning("Failed to bump credential catalogue version: %s", e)
+
     async def store_api_key(
         self,
         provider: str,
         api_key: str,
         models: List[str],
-        session_id: str = "default"
+        session_id: str = "default",
+        model_params: Optional[Dict[str, Dict[str, Any]]] = None,
     ) -> bool:
         """Store API key with models in encrypted credentials database.
 
@@ -57,6 +123,11 @@ class AuthService:
             api_key: The API key to store (will be encrypted)
             models: List of available models for this key
             session_id: Session identifier for multi-user support
+            model_params: Optional per-model parameters (context_length etc.)
+                — used by local providers (Ollama, LM Studio) where the
+                context window depends on what the user has loaded.
+                Forwarded straight to the credentials DB so
+                ``model_registry`` can read real values at runtime.
 
         Returns:
             True if stored successfully, False otherwise
@@ -66,17 +137,28 @@ class AuthService:
 
             logger.info(f"Storing API key for provider: {provider}, session: {session_id}")
 
-            # Store in encrypted credentials database
+            # 1. DB write first (canonical source).
             await self.credentials_db.save_api_key(
                 provider=provider,
                 api_key=api_key,
                 models=models,
-                session_id=session_id
+                session_id=session_id,
+                model_params=model_params,
+            )
+
+            # 2. Cache update only after DB write succeeds. One entry,
+            #    not two parallel dicts — see ApiKeyCacheEntry docstring.
+            self._api_key_cache[cache_key] = ApiKeyCacheEntry(
+                key=api_key,
+                models=list(models),
             )
 
-            # Cache decrypted key in memory only (for quick access)
-            self._memory_cache[cache_key] = api_key
-            self._models_cache[cache_key] = models
+            # 3. Bump the catalogue version so the frontend's conditional
+            #    fetch (``since: <prior version>``) returns a fresh
+            #    catalogue instead of ``{unchanged: true}`` — without
+            #    this the per-provider ``stored`` flag stays stale on
+            #    every connected client until the process restarts.
+            self._bump_catalogue_version()
 
             logger.info(f"Stored and cached API key for {provider}")
             return True
@@ -85,6 +167,26 @@ class AuthService:
             logger.error("Failed to store API key", provider=provider, error=str(e))
             return False
 
+    async def get_model_params(
+        self, provider: str, session_id: str = "default"
+    ) -> Dict[str, Dict[str, Any]]:
+        """Return per-model params (context_length etc.) for the provider.
+
+        Reads straight from the credentials DB — there's no in-memory
+        cache for these because they're consulted at most once per
+        chat-model execution and the DB read is cheap. Empty dict for
+        cloud providers (whose per-model params live in
+        ``model_registry.json``) and for any local provider that hasn't
+        been validated yet.
+        """
+        try:
+            return await self.credentials_db.get_api_key_model_params(
+                provider, session_id
+            )
+        except Exception as e:
+            logger.error("Failed to get model_params", provider=provider, error=str(e))
+            return {}
+
     async def get_api_key(self, provider: str, session_id: str = "default") -> Optional[str]:
         """Get decrypted API key.
 
@@ -100,15 +202,23 @@ class AuthService:
         try:
             cache_key = f"{session_id}_{provider}"
 
-            # Check memory cache first (fastest, most secure)
-            if cache_key in self._memory_cache:
-                return self._memory_cache[cache_key]
+            # Check memory cache first (fastest, most secure).
+            entry = self._api_key_cache.get(cache_key)
+            if entry is not None:
+                return entry.key
 
-            # Fallback to encrypted database
+            # Fallback to encrypted database. The lazy fetch also pulls
+            # the models list so we populate the cache entry fully — no
+            # second roundtrip on the next get_stored_models() call.
             api_key = await self.credentials_db.get_api_key(provider, session_id)
             if api_key:
-                # Cache in memory for quick subsequent access
-                self._memory_cache[cache_key] = api_key
+                models = await self.credentials_db.get_api_key_models(
+                    provider, session_id
+                ) or []
+                self._api_key_cache[cache_key] = ApiKeyCacheEntry(
+                    key=api_key,
+                    models=models,
+                )
                 return api_key
 
             return None
@@ -131,13 +241,21 @@ class AuthService:
             cache_key = f"{session_id}_{provider}"
 
             # Check memory cache first
-            if cache_key in self._models_cache:
-                return self._models_cache[cache_key]
+            entry = self._api_key_cache.get(cache_key)
+            if entry is not None:
+                return entry.models
 
-            # Fallback to encrypted database
+            # Fallback to encrypted database. Pull the key alongside so
+            # the cache entry is populated fully — symmetric with
+            # get_api_key()'s lazy-populate path.
             models = await self.credentials_db.get_api_key_models(provider, session_id)
             if models:
-                self._models_cache[cache_key] = models
+                api_key = await self.credentials_db.get_api_key(provider, session_id)
+                if api_key:
+                    self._api_key_cache[cache_key] = ApiKeyCacheEntry(
+                        key=api_key,
+                        models=list(models),
+                    )
                 return models
 
             return []
@@ -159,13 +277,15 @@ class AuthService:
         try:
             cache_key = f"{session_id}_{provider}"
 
-            # Remove from memory cache
-            self._memory_cache.pop(cache_key, None)
-            self._models_cache.pop(cache_key, None)
-
-            # Remove from encrypted database
+            # 1. DB delete first (canonical source).
             await self.credentials_db.delete_api_key(provider, session_id)
 
+            # 2. Cache evict only after DB succeeds. One pop, not two.
+            self._api_key_cache.pop(cache_key, None)
+
+            # 3. Bump the catalogue version — same reason as store.
+            self._bump_catalogue_version()
+
             logger.info(f"Removed API key for {provider}")
             return True
 
@@ -192,8 +312,7 @@ class AuthService:
         Should be called on user logout to ensure decrypted keys
         don't persist in memory longer than necessary.
         """
-        self._memory_cache.clear()
-        self._models_cache.clear()
+        self._api_key_cache.clear()
         self._oauth_cache.clear()
         logger.debug("Cleared all credential memory caches")
 
@@ -226,6 +345,7 @@ class AuthService:
         try:
             cache_key = f"{customer_id}_{provider}"
 
+            # 1. DB write first (canonical source).
             await self.credentials_db.save_oauth_tokens(
                 provider=provider,
                 access_token=access_token,
@@ -236,15 +356,22 @@ class AuthService:
                 customer_id=customer_id
             )
 
-            # Cache in memory
+            # 2. Cache only the access token + display fields. Refresh
+            #    tokens are long-lived secrets per RFC 9700 (OAuth 2.0
+            #    BCP 2024) and are NOT cached in memory — readers go
+            #    through ``get_oauth_refresh_token()`` which hits the DB.
             self._oauth_cache[cache_key] = {
                 "access_token": access_token,
-                "refresh_token": refresh_token,
                 "email": email,
                 "name": name,
-                "scopes": scopes
+                "scopes": scopes,
             }
 
+            # 3. Bump the catalogue version so the frontend's conditional
+            #    fetch returns fresh ``stored`` flags after this OAuth
+            #    save (login).
+            self._bump_catalogue_version()
+
             logger.info(f"Stored OAuth tokens for {provider}")
             return True
 
@@ -257,27 +384,42 @@ class AuthService:
         provider: str,
         customer_id: str = "owner"
     ) -> Optional[Dict[str, Any]]:
-        """Get OAuth tokens from cache or encrypted database.
+        """Get OAuth display tokens from cache or encrypted database.
+
+        Returns ``{access_token, email, name, scopes}`` only — the
+        refresh token is intentionally NOT included. Callers that need
+        the refresh token (token-refresh + revoke flows) must call
+        :meth:`get_oauth_refresh_token` explicitly. This split implements
+        RFC 9700 (OAuth 2.0 BCP 2024) §5.1 — refresh tokens are
+        long-lived secrets and must not live in process memory.
 
         Args:
             provider: OAuth provider name
             customer_id: Customer identifier
 
         Returns:
-            Dict with access_token, refresh_token, email, name, scopes or None
+            Dict with ``access_token``, ``email``, ``name``, ``scopes`` or
+            ``None`` if no tokens are stored.
         """
         try:
             cache_key = f"{customer_id}_{provider}"
 
-            # Check memory cache first
+            # Check memory cache first.
             if cache_key in self._oauth_cache:
                 return self._oauth_cache[cache_key]
 
-            # Fallback to encrypted database
+            # Fallback to encrypted database. Strip refresh_token before
+            # caching so the in-memory copy is short-lived-display-only.
             tokens = await self.credentials_db.get_oauth_tokens(provider, customer_id)
             if tokens:
-                self._oauth_cache[cache_key] = tokens
-                return tokens
+                display = {
+                    "access_token": tokens.get("access_token"),
+                    "email": tokens.get("email"),
+                    "name": tokens.get("name"),
+                    "scopes": tokens.get("scopes"),
+                }
+                self._oauth_cache[cache_key] = display
+                return display
 
             return None
 
@@ -285,6 +427,38 @@ class AuthService:
             logger.error("Failed to get OAuth tokens", provider=provider, error=str(e))
             return None
 
+    async def get_oauth_refresh_token(
+        self,
+        provider: str,
+        customer_id: str = "owner",
+    ) -> Optional[str]:
+        """Read the OAuth refresh token directly from the encrypted DB.
+
+        Per RFC 9700 (OAuth 2.0 BCP 2024) §5.1 the refresh token is a
+        long-lived bearer secret and must not be cached in process
+        memory. Every call decrypts from disk; this is acceptable
+        because refresh tokens are accessed rarely (only at access-token
+        renewal + on revoke / logout).
+
+        Args:
+            provider: OAuth provider name
+            customer_id: Customer identifier
+
+        Returns:
+            The decrypted refresh token, or ``None`` if no tokens are
+            stored for ``(provider, customer_id)``.
+        """
+        try:
+            tokens = await self.credentials_db.get_oauth_tokens(provider, customer_id)
+            if tokens:
+                return tokens.get("refresh_token")
+            return None
+        except Exception as e:
+            logger.error(
+                "Failed to get OAuth refresh token", provider=provider, error=str(e)
+            )
+            return None
+
     async def refresh_oauth_tokens_with_breaker(
         self,
         provider: str,
@@ -388,11 +562,14 @@ class AuthService:
         try:
             cache_key = f"{customer_id}_{provider}"
 
-            # Remove from memory cache
+            # 1. DB delete first (canonical source).
+            await self.credentials_db.delete_oauth_tokens(provider, customer_id)
+
+            # 2. Cache evict after DB succeeds.
             self._oauth_cache.pop(cache_key, None)
 
-            # Remove from encrypted database
-            await self.credentials_db.delete_oauth_tokens(provider, customer_id)
+            # 3. Bump the catalogue version — same reason as store.
+            self._bump_catalogue_version()
 
             logger.info(f"Removed OAuth tokens for {provider}")
             return True