langflow-base-nightly 1.7.0.dev52__py3-none-any.whl → 1.7.0.dev53__py3-none-any.whl

langflow/inputs/__init__.py

@@ -18,6 +18,7 @@ from lfx.inputs.inputs import (
     McpInput,
     MessageInput,
     MessageTextInput,
+    ModelInput,
     MultilineInput,
     MultilineSecretInput,
     MultiselectInput,
@@ -53,6 +54,7 @@ __all__ = [
     "McpInput",
     "MessageInput",
     "MessageTextInput",
+    "ModelInput",
     "MultilineInput",
     "MultilineSecretInput",
     "MultiselectInput",

langflow/inputs/inputs.py

@@ -24,6 +24,7 @@ from lfx.inputs.inputs import (
     McpInput,
     MessageInput,
     MessageTextInput,
+    ModelInput,
     MultilineInput,
     MultilineSecretInput,
     MultiselectInput,
@@ -58,6 +59,7 @@ __all__ = [
     "McpInput",
     "MessageInput",
     "MessageTextInput",
+    "ModelInput",
     "MultilineInput",
     "MultilineSecretInput",
     "MultiselectInput",

langflow/main.py

@@ -46,6 +46,7 @@ from langflow.services.deps import (
 )
 from langflow.services.schema import ServiceType
 from langflow.services.utils import initialize_services, initialize_settings_service, teardown_services
+from langflow.utils.mcp_cleanup import cleanup_mcp_sessions
 
 if TYPE_CHECKING:
     from tempfile import TemporaryDirectory
@@ -320,6 +321,10 @@ def get_lifespan(*, fix_migration=False, version=None):
                 await log_exception_to_telemetry(exc, "lifespan")
             raise
         finally:
+            # CRITICAL: Cleanup MCP sessions FIRST, before any other shutdown logic.
+            # This ensures MCP subprocesses are killed even if shutdown is interrupted.
+            await cleanup_mcp_sessions()
+
             # Clean shutdown with progress indicator
             # Create shutdown progress (show verbose timing if log level is DEBUG)
             from langflow.__main__ import get_number_of_workers

langflow/memory.py

@@ -164,9 +164,7 @@ async def aupdate_messages(messages: Message | list[Message]) -> list[Message]:
                 # Convert flow_id to UUID if it's a string preventing error when saving to database
                 if msg.flow_id and isinstance(msg.flow_id, str):
                     msg.flow_id = UUID(msg.flow_id)
-                result = session.add(msg)
-                if asyncio.iscoroutine(result):
-                    await result
+                session.add(msg)
                 updated_messages.append(msg)
             else:
                 error_message = f"Message with id {message.id} not found"
@@ -192,9 +190,7 @@ async def aadd_messagetables(messages: list[MessageTable], session: AsyncSession
     try:
         try:
             for message in messages:
-                result = session.add(message)
-                if asyncio.iscoroutine(result):
-                    await result
+                session.add(message)
             await session.commit()
             # This is a hack.
             # We are doing this because build_public_tmp causes the CancelledError to be raised

langflow/processing/process.py

@@ -151,15 +151,19 @@ def apply_tweaks(node: dict[str, Any], node_tweaks: dict[str, Any]) -> None:
             logger.warning("Security: Code field cannot be overridden via tweaks.")
             continue
         if tweak_name in template_data:
-            if template_data[tweak_name]["type"] == "NestedDict":
+            field_type = template_data[tweak_name].get("type", "")
+            if field_type == "NestedDict":
                 value = validate_and_repair_json(tweak_value)
                 template_data[tweak_name]["value"] = value
+            elif field_type == "mcp":
+                # MCP fields expect dict values to be set directly
+                template_data[tweak_name]["value"] = tweak_value
             elif isinstance(tweak_value, dict):
                 for k, v in tweak_value.items():
-                    k_ = "file_path" if template_data[tweak_name]["type"] == "file" else k
+                    k_ = "file_path" if field_type == "file" else k
                     template_data[tweak_name][k_] = v
             else:
-                key = "file_path" if template_data[tweak_name]["type"] == "file" else "value"
+                key = "file_path" if field_type == "file" else "value"
                 template_data[tweak_name][key] = tweak_value
 
 

langflow/services/database/models/variable/model.py

@@ -48,8 +48,6 @@ class Variable(VariableBase, table=True):  # type: ignore[call-arg]
 class VariableCreate(VariableBase):
     created_at: datetime | None = Field(default_factory=utc_now, description="Creation time of the variable")
 
-    updated_at: datetime | None = Field(default_factory=utc_now, description="Creation time of the variable")
-
 
 class VariableRead(SQLModel):
     id: UUID
@@ -71,3 +69,4 @@ class VariableUpdate(SQLModel):
     name: str | None = Field(None, description="Name of the variable")
     value: str | None = Field(None, description="Encrypted value of the variable")
     default_fields: list[str] | None = Field(None, description="Default fields for the variable")
+    type: str | None = Field(None, description="Type of the variable")

langflow/services/deps.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 from langflow.services.schema import ServiceType
 
@@ -176,7 +176,7 @@ async def session_scope() -> AsyncGenerator[AsyncSession, None]:
         yield session
 
 
-def get_cache_service() -> Union[CacheService, AsyncBaseCacheService]:  # noqa: UP007
+def get_cache_service() -> CacheService | AsyncBaseCacheService:
     """Retrieves the cache service from the service manager.
 
     Returns:

langflow/services/tracing/arize_phoenix.py

@@ -3,8 +3,10 @@ from __future__ import annotations
 import json
 import math
 import os
+import threading
 import traceback
 import types
+import uuid
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any
 
@@ -13,6 +15,7 @@ from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from openinference.semconv.trace import OpenInferenceMimeTypeValues, SpanAttributes
+from opentelemetry.sdk.trace.export import SpanProcessor
 from opentelemetry.semconv.trace import SpanAttributes as OTELSpanAttributes
 from opentelemetry.trace import Span, Status, StatusCode, use_span
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
@@ -33,6 +36,34 @@ if TYPE_CHECKING:
     from langflow.services.tracing.schema import Log
 
 
+class CollectingSpanProcessor(SpanProcessor):
+    def __init__(self):
+        self.correlation_id = None
+        self._lock = threading.Lock()
+
+    def on_start(self, span, parent_context=None):
+        # Silence unused variable warnings
+        _ = parent_context
+
+        # Generate the correlation ID once (thread-safe)
+        with self._lock:
+            if self.correlation_id is None:
+                self.correlation_id = str(uuid.uuid4())
+
+        # Inject into the CHAIN & LLM spans
+        if span.name in ("Langflow", "Language Model"):
+            span.set_attribute("langflow.correlation_id", self.correlation_id)
+
+    def on_end(self, span):
+        pass
+
+    def shutdown(self):
+        pass
+
+    def force_flush(self, timeout_millis=30000):
+        pass
+
+
 class ArizePhoenixTracer(BaseTracer):
     flow_name: str
     flow_id: str
@@ -47,11 +78,11 @@ class ArizePhoenixTracer(BaseTracer):
         self.trace_type = trace_type
         self.project_name = project_name
         self.trace_id = trace_id
+        self.session_id = session_id
         self.flow_name = trace_name.split(" - ")[0]
         self.flow_id = trace_name.split(" - ")[-1]
         self.chat_input_value = ""
         self.chat_output_value = ""
-        self.session_id = session_id
 
         try:
             self._ready = self.setup_arize_phoenix()
@@ -63,22 +94,26 @@ class ArizePhoenixTracer(BaseTracer):
             self.carrier: dict[Any, CarrierT] = {}
 
             self.root_span = self.tracer.start_span(
-                name=self.flow_id,
+                name="Langflow",
                 start_time=self._get_current_timestamp(),
             )
             self.root_span.set_attribute(SpanAttributes.SESSION_ID, self.session_id or self.flow_id)
             self.root_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND, self.trace_type)
-            self.root_span.set_attribute("langflow.project.name", self.project_name)
-            self.root_span.set_attribute("langflow.flow.name", self.flow_name)
-            self.root_span.set_attribute("langflow.flow.id", self.flow_id)
+            self.root_span.set_attribute("langflow.trace_name", self.trace_name)
+            self.root_span.set_attribute("langflow.trace_type", self.trace_type)
+            self.root_span.set_attribute("langflow.project_name", self.project_name)
+            self.root_span.set_attribute("langflow.trace_id", str(self.trace_id))
+            self.root_span.set_attribute("langflow.session_id", str(self.session_id))
+            self.root_span.set_attribute("langflow.flow_name", self.flow_name)
+            self.root_span.set_attribute("langflow.flow_id", self.flow_id)
 
             with use_span(self.root_span, end_on_exit=False):
                 self.propagator.inject(carrier=self.carrier)
 
             self.child_spans: dict[str, Span] = {}
 
-        except Exception:  # noqa: BLE001
-            logger.debug("Error setting up Arize/Phoenix tracer", exc_info=True)
+        except Exception as e:  # noqa: BLE001
+            logger.error("[Arize/Phoenix] Error Setting Up Tracer: %s", str(e), exc_info=True)
             self._ready = False
 
     @property
@@ -161,10 +196,12 @@ class ArizePhoenixTracer(BaseTracer):
                     )
                 )
 
+            tracer_provider.add_span_processor(CollectingSpanProcessor())
             self.tracer_provider = tracer_provider
         except ImportError:
             logger.exception(
-                "Could not import arize-phoenix-otel. Please install it with `pip install arize-phoenix-otel`."
+                "[Arize/Phoenix] Could not import Arize Phoenix OTEL packages."
+                "Please install it with `pip install arize-phoenix-otel`."
             )
             return False
 
@@ -174,7 +211,7 @@ class ArizePhoenixTracer(BaseTracer):
             LangChainInstrumentor().instrument(tracer_provider=self.tracer_provider, skip_dep_check=True)
         except ImportError:
             logger.exception(
-                "Could not import LangChainInstrumentor."
+                "[Arize/Phoenix] Could not import LangChainInstrumentor."
                 "Please install it with `pip install openinference-instrumentation-langchain`."
             )
             return False
@@ -217,6 +254,9 @@ class ArizePhoenixTracer(BaseTracer):
             for key, value in processed_metadata.items():
                 child_span.set_attribute(f"{SpanAttributes.METADATA}.{key}", value)
 
+        if vertex and vertex.id is not None:
+            child_span.set_attribute("vertex_id", vertex.id)
+
         component_name = trace_id.split("-")[0]
         if component_name == "ChatInput":
             self.chat_input_value = processed_inputs["input_value"]
@@ -280,15 +320,14 @@ class ArizePhoenixTracer(BaseTracer):
                     self.root_span.set_attribute(f"{SpanAttributes.METADATA}.{key}", value)
 
             self._set_span_status(self.root_span, error)
-            self.root_span.end()
-
+            self.root_span.end(end_time=self._get_current_timestamp())
         try:
             from openinference.instrumentation.langchain import LangChainInstrumentor
 
             LangChainInstrumentor().uninstrument(tracer_provider=self.tracer_provider, skip_dep_check=True)
         except ImportError:
             logger.exception(
-                "Could not import LangChainInstrumentor."
+                "[Arize/Phoenix] Could not import LangChainInstrumentor."
                 "Please install it with `pip install openinference-instrumentation-langchain`."
             )
 
@@ -373,3 +412,15 @@ class ArizePhoenixTracer(BaseTracer):
     def get_langchain_callback(self) -> BaseCallbackHandler | None:
         """Returns the LangChain callback handler if applicable."""
         return None
+
+    def close(self):
+        """Flush tracer provider spans safely before shutdown."""
+        try:
+            if hasattr(self, "tracer_provider") and hasattr(self.tracer_provider, "force_flush"):
+                self.tracer_provider.force_flush(timeout_millis=3000)
+        except (ValueError, RuntimeError, OSError) as e:
+            logger.error("[Arize/Phoenix] Error Flushing Spans: %s", str(e), exc_info=True)
+
+    def __del__(self):
+        """Ensure tracer provider flushes on object destruction."""
+        self.close()

langflow/services/variable/base.py

@@ -4,7 +4,7 @@ from uuid import UUID
 from sqlmodel.ext.asyncio.session import AsyncSession
 
 from langflow.services.base import Service
-from langflow.services.database.models.variable.model import Variable, VariableRead
+from langflow.services.database.models.variable.model import Variable, VariableRead, VariableUpdate
 
 
 class VariableService(Service):
@@ -117,3 +117,45 @@ class VariableService(Service):
             user_id: The user ID.
             session: The database session.
         """
+
+    @abc.abstractmethod
+    async def get_variable_by_id(self, user_id: UUID | str, variable_id: UUID | str, session: AsyncSession) -> Variable:
+        """Get a variable by ID.
+
+        Args:
+            user_id: The user ID.
+            variable_id: The ID of the variable.
+            session: The database session.
+
+        Returns:
+            The variable.
+        """
+
+    @abc.abstractmethod
+    async def get_variable_object(self, user_id: UUID | str, name: str, session: AsyncSession) -> Variable:
+        """Get a variable object by name.
+
+        Args:
+            user_id: The user ID.
+            name: The name of the variable.
+            session: The database session.
+
+        Returns:
+            The variable object.
+        """
+
+    @abc.abstractmethod
+    async def update_variable_fields(
+        self, user_id: UUID | str, variable_id: UUID | str, variable: VariableUpdate, session: AsyncSession
+    ) -> Variable:
+        """Update specific fields of a variable.
+
+        Args:
+            user_id: The user ID.
+            variable_id: The ID of the variable.
+            variable: The variable update model with fields to update.
+            session: The database session.
+
+        Returns:
+            The updated variable.
+        """

langflow/services/variable/kubernetes.py

@@ -9,7 +9,7 @@ from typing_extensions import override
 
 from langflow.services.auth import utils as auth_utils
 from langflow.services.base import Service
-from langflow.services.database.models.variable.model import Variable, VariableCreate, VariableRead
+from langflow.services.database.models.variable.model import Variable, VariableCreate, VariableRead, VariableUpdate
 from langflow.services.variable.base import VariableService
 from langflow.services.variable.constants import CREDENTIAL_TYPE, GENERIC_TYPE
 from langflow.services.variable.kubernetes_secrets import KubernetesSecretManager, encode_user_id
@@ -201,3 +201,67 @@ class KubernetesSecretService(VariableService, Service):
             variables_read.append(variable_read)
 
         return variables_read
+
+    @override
+    async def get_variable_by_id(self, user_id: UUID | str, variable_id: UUID | str, session: AsyncSession) -> Variable:
+        """Get a variable by ID.
+
+        Note: Kubernetes secrets don't have IDs, so we use the variable_id as the name.
+        """
+        secret_name = encode_user_id(user_id)
+        key, value = await asyncio.to_thread(self.resolve_variable, secret_name, user_id, str(variable_id))
+
+        name = key
+        type_ = GENERIC_TYPE
+        if key.startswith(CREDENTIAL_TYPE + "_"):
+            name = key[len(CREDENTIAL_TYPE) + 1 :]
+            type_ = CREDENTIAL_TYPE
+
+        variable_base = VariableCreate(
+            name=name,
+            type=type_,
+            value=auth_utils.encrypt_api_key(value, settings_service=self.settings_service),
+            default_fields=[],
+        )
+        return Variable.model_validate(variable_base, from_attributes=True, update={"user_id": user_id})
+
+    @override
+    async def get_variable_object(self, user_id: UUID | str, name: str, session: AsyncSession) -> Variable:
+        """Get a variable object by name."""
+        secret_name = encode_user_id(user_id)
+        key, value = await asyncio.to_thread(self.resolve_variable, secret_name, user_id, name)
+
+        var_name = key
+        type_ = GENERIC_TYPE
+        if key.startswith(CREDENTIAL_TYPE + "_"):
+            var_name = key[len(CREDENTIAL_TYPE) + 1 :]
+            type_ = CREDENTIAL_TYPE
+
+        variable_base = VariableCreate(
+            name=var_name,
+            type=type_,
+            value=auth_utils.encrypt_api_key(value, settings_service=self.settings_service),
+            default_fields=[],
+        )
+        return Variable.model_validate(variable_base, from_attributes=True, update={"user_id": user_id})
+
+    @override
+    async def update_variable_fields(
+        self, user_id: UUID | str, variable_id: UUID | str, variable: VariableUpdate, session: AsyncSession
+    ) -> Variable:
+        """Update specific fields of a variable.
+
+        Note: Kubernetes secrets don't have IDs, so we use the variable name for updates.
+        """
+        if variable.name:
+            name = variable.name
+        else:
+            # Try to get the current variable to find its name
+            current_var = await self.get_variable_by_id(user_id, variable_id, session)
+            name = current_var.name
+
+        if variable.value is not None:
+            await self.update_variable(user_id, name, variable.value, session)
+
+        # Return the updated variable
+        return await self.get_variable_object(user_id, name, session)

langflow/services/variable/service.py

@@ -6,7 +6,6 @@ from typing import TYPE_CHECKING
 
 from lfx.log.logger import logger
 from sqlmodel import select
-from typing_extensions import override
 
 from langflow.services.auth import utils as auth_utils
 from langflow.services.base import Service
@@ -31,6 +30,16 @@ class DatabaseVariableService(VariableService, Service):
             await logger.adebug("Skipping environment variable storage.")
             return
 
+        # Import the provider mapping to set default_fields for known providers
+        try:
+            from lfx.base.models.unified_models import get_model_provider_variable_mapping
+
+            provider_mapping = get_model_provider_variable_mapping()
+            # Reverse the mapping to go from variable name to provider
+            var_to_provider = {var_name: provider for provider, var_name in provider_mapping.items()}
+        except Exception:  # noqa: BLE001
+            var_to_provider = {}
+
         for var_name in self.settings_service.settings.variables_to_get_from_environment:
             # Check if session is still usable before processing each variable
             if not session.is_active:
@@ -42,8 +51,24 @@ class DatabaseVariableService(VariableService, Service):
 
             if var_name in os.environ and os.environ[var_name].strip():
                 value = os.environ[var_name].strip()
+
+                # Skip placeholder/test values like "dummy" for API key variables only
+                # This prevents test environments from overwriting user-configured model provider keys
+                is_api_key_variable = var_name in var_to_provider
+                if is_api_key_variable and value.lower() == "dummy":
+                    await logger.adebug(
+                        f"Skipping API key variable {var_name} with placeholder value 'dummy' "
+                        "to preserve user configuration"
+                    )
+                    continue
+
                 query = select(Variable).where(Variable.user_id == user_id, Variable.name == var_name)
+                # Set default_fields if this is a known provider variable
+                default_fields = []
                 try:
+                    if is_api_key_variable:
+                        provider_name = var_to_provider[var_name]
+                        default_fields = [provider_name, "api_key"]
                     existing = (await session.exec(query)).first()
                 except Exception as e:  # noqa: BLE001
                     await logger.aexception(f"Error querying {var_name} variable: {e!s}")
@@ -57,13 +82,53 @@ class DatabaseVariableService(VariableService, Service):
 
                 try:
                     if existing:
-                        await self.update_variable(user_id, var_name, value, session)
+                        # Check if the variable has been user-modified (updated_at != created_at)
+                        # If so, don't overwrite with environment variable
+                        is_user_modified = (
+                            existing.updated_at is not None
+                            and existing.created_at is not None
+                            and existing.updated_at > existing.created_at
+                        )
+
+                        if is_user_modified:
+                            # Variable was modified by user, don't overwrite with environment variable
+                            # Only update default_fields if they're not set
+                            if not existing.default_fields and default_fields:
+                                variable_update = VariableUpdate(
+                                    id=existing.id,
+                                    default_fields=default_fields,
+                                )
+                                await self.update_variable_fields(
+                                    user_id=user_id,
+                                    variable_id=existing.id,
+                                    variable=variable_update,
+                                    session=session,
+                                )
+                            await logger.adebug(
+                                f"Skipping update of user-modified variable {var_name} with environment value"
+                            )
+                        # Variable was not user-modified, safe to update from environment
+                        elif not existing.default_fields and default_fields:
+                            # Update both value and default_fields
+                            variable_update = VariableUpdate(
+                                id=existing.id,
+                                value=value,
+                                default_fields=default_fields,
+                            )
+                            await self.update_variable_fields(
+                                user_id=user_id,
+                                variable_id=existing.id,
+                                variable=variable_update,
+                                session=session,
+                            )
+                        else:
+                            await self.update_variable(user_id, var_name, value, session=session)
                     else:
                         await self.create_variable(
                             user_id=user_id,
                             name=var_name,
                             value=value,
-                            default_fields=[],
+                            default_fields=default_fields,
                             type_=CREDENTIAL_TYPE,
                             session=session,
                         )
@@ -77,15 +142,13 @@ class DatabaseVariableService(VariableService, Service):
                         )
                         break
 
-    async def get_variable(
+    async def get_variable_object(
         self,
         user_id: UUID | str,
         name: str,
-        field: str,
         session: AsyncSession,
-    ) -> str:
+    ) -> Variable:
         # we get the credential from the database
-        # credential = session.query(Variable).filter(Variable.user_id == user_id, Variable.name == name).first()
         stmt = select(Variable).where(Variable.user_id == user_id, Variable.name == name)
         variable = (await session.exec(stmt)).first()
 
@@ -93,6 +156,19 @@ class DatabaseVariableService(VariableService, Service):
             msg = f"{name} variable not found."
             raise ValueError(msg)
 
+        return variable
+
+    async def get_variable(
+        self,
+        user_id: UUID | str,
+        name: str,
+        field: str,
+        session: AsyncSession,
+    ) -> str:
+        # we get the credential from the database
+        # credential = session.query(Variable).filter(Variable.user_id == user_id, Variable.name == name).first()
+        variable = await self.get_variable_object(user_id, name, session)
+
         if variable.type == CREDENTIAL_TYPE and field == "session_id":
             msg = (
                 f"variable {name} of type 'Credential' cannot be used in a Session ID field "
@@ -124,6 +200,19 @@ class DatabaseVariableService(VariableService, Service):
             variables_read.append(variable_read)
         return variables_read
 
+    async def get_variable_by_id(
+        self,
+        user_id: UUID | str,
+        variable_id: UUID | str,
+        session: AsyncSession,
+    ) -> Variable:
+        query = select(Variable).where(Variable.id == variable_id, Variable.user_id == user_id)
+        variable = (await session.exec(query)).first()
+        if not variable:
+            msg = f"{variable_id} variable not found."
+            raise ValueError(msg)
+        return variable
+
     async def list_variables(self, user_id: UUID | str, session: AsyncSession) -> list[str | None]:
         variables = await self.get_all(user_id=user_id, session=session)
         return [variable.name for variable in variables if variable]
@@ -140,8 +229,12 @@ class DatabaseVariableService(VariableService, Service):
         if not variable:
             msg = f"{name} variable not found."
             raise ValueError(msg)
-        encrypted = auth_utils.encrypt_api_key(value, settings_service=self.settings_service)
-        variable.value = encrypted
+        # Only encrypt CREDENTIAL_TYPE variables
+        if variable.type == CREDENTIAL_TYPE:
+            variable.value = auth_utils.encrypt_api_key(value, settings_service=self.settings_service)
+        else:
+            variable.value = value
+        variable.updated_at = datetime.now(timezone.utc)
         session.add(variable)
         await session.flush()
         await session.refresh(variable)
@@ -158,9 +251,16 @@ class DatabaseVariableService(VariableService, Service):
         db_variable = (await session.exec(query)).one()
         db_variable.updated_at = datetime.now(timezone.utc)
 
-        variable.value = variable.value or ""
-        encrypted = auth_utils.encrypt_api_key(variable.value, settings_service=self.settings_service)
-        variable.value = encrypted
+        # Use the variable's type if provided, otherwise use the db_variable's type
+        variable_type = variable.type or db_variable.type
+
+        # Only process value if it's actually provided (not None)
+        if variable.value is not None:
+            # Handle empty string as valid value
+            value_to_store = variable.value
+            if variable_type == CREDENTIAL_TYPE:
+                encrypted = auth_utils.encrypt_api_key(value_to_store, settings_service=self.settings_service)
+                variable.value = encrypted
 
         variable_data = variable.model_dump(exclude_unset=True)
         for key, value in variable_data.items():
@@ -171,7 +271,6 @@ class DatabaseVariableService(VariableService, Service):
         await session.refresh(db_variable)
         return db_variable
 
-    @override
     async def delete_variable(
         self,
         user_id: UUID | str,
@@ -185,7 +284,6 @@ class DatabaseVariableService(VariableService, Service):
             raise ValueError(msg)
         await session.delete(variable)
 
-    @override
     async def delete_variable_by_id(self, user_id: UUID | str, variable_id: UUID, session: AsyncSession) -> None:
         stmt = select(Variable).where(Variable.user_id == user_id, Variable.id == variable_id)
         variable = (await session.exec(stmt)).first()
@@ -204,10 +302,16 @@ class DatabaseVariableService(VariableService, Service):
         type_: str = CREDENTIAL_TYPE,
         session: AsyncSession,
     ):
+        # Only encrypt CREDENTIAL_TYPE variables
+        encrypted_value = (
+            auth_utils.encrypt_api_key(value, settings_service=self.settings_service)
+            if type_ == CREDENTIAL_TYPE
+            else value
+        )
         variable_base = VariableCreate(
             name=name,
             type=type_,
-            value=auth_utils.encrypt_api_key(value, settings_service=self.settings_service),
+            value=encrypted_value,
             default_fields=list(default_fields),
         )
         variable = Variable.model_validate(variable_base, from_attributes=True, update={"user_id": user_id})