streamlit-nightly 1.52.3.dev20260107__tar.gz → 1.52.3.dev20260109__tar.gz

{streamlit_nightly-1.52.3.dev20260107 → streamlit_nightly-1.52.3.dev20260109}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-nightly
-Version: 1.52.3.dev20260107
+Version: 1.52.3.dev20260109
 Summary: A faster way to build and share data apps
 Home-page: https://streamlit.io
 Author: Snowflake Inc

{streamlit_nightly-1.52.3.dev20260107 → streamlit_nightly-1.52.3.dev20260109}/setup.py

@@ -23,7 +23,7 @@ from setuptools.command.install import install
 
 THIS_DIRECTORY = Path(__file__).parent
 
-VERSION = "1.52.3.dev20260107"  # PEP-440
+VERSION = "1.52.3.dev20260109"  # PEP-440
 
 # IMPORTANT: We should try very hard *not* to add dependencies to Streamlit.
 # And if you do add one, make the required version as general as possible:

{streamlit_nightly-1.52.3.dev20260107 → streamlit_nightly-1.52.3.dev20260109}/streamlit/components/v2/__init__.py

@@ -28,7 +28,7 @@ from streamlit.components.v2.get_bidi_component_manager import (
 from streamlit.errors import StreamlitAPIException
 
 if TYPE_CHECKING:
-    from streamlit.components.v2.types import BidiComponentCallable
+    from streamlit.components.v2.types import ComponentRenderer
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -211,7 +211,7 @@ def component(
     css: str | None = None,
     js: str | None = None,
     isolate_styles: bool = True,
-) -> BidiComponentCallable:
+) -> ComponentRenderer:
     '''Register an ``st.components.v2`` component and return a callable to mount it.
 
     Components may provide any combination of HTML, CSS, and JavaScript. If none
@@ -287,7 +287,7 @@ def component(
 
     Returns
     -------
-    BidiComponentCallable
+    ComponentRenderer
         The component's mounting command.
 
         This callable accepts the component parameters like ``key`` and

{streamlit_nightly-1.52.3.dev20260107 → streamlit_nightly-1.52.3.dev20260109}/streamlit/components/v2/types.py

@@ -45,7 +45,7 @@ BidiComponentDefaults = dict[str, Any] | None
 ComponentIsolateStyles = bool
 
 
-class BidiComponentCallable(Protocol):
+class ComponentRenderer(Protocol):
     '''Signature of the mounting command returned by ``st.components.v2.component``.
 
     This callable mounts a bidirectional component in a Streamlit app and
@@ -69,8 +69,8 @@ class BidiComponentCallable(Protocol):
         .. note::
             If you want to access this key in your component's frontend, you
             must pass it explicitly within the ``data`` parameter. The ``key``
-            parameter in ``BidiComponentCallable`` is not the same as the
-            ``key`` property in ``ComponentArgs`` in the component's frontend
+            parameter in ``ComponentRenderer`` is not the same as the
+            ``key`` property in ``FrontendRendererArgs`` in the component's frontend
             code.
 
             The frontend key is automatically generated to be unique among all
@@ -309,9 +309,9 @@ class BidiComponentCallable(Protocol):
 
 
 __all__ = [
-    "BidiComponentCallable",
     "BidiComponentData",
     "BidiComponentDefaults",
     "BidiComponentKey",
     "ComponentIsolateStyles",
+    "ComponentRenderer",
 ]

{streamlit_nightly-1.52.3.dev20260107 → streamlit_nightly-1.52.3.dev20260109}/streamlit/config.py

@@ -62,6 +62,20 @@ _config_options: dict[str, ConfigOption] | None = None
 # resolve config and secret files relative to the main script:
 _main_script_path: str | None = None
 
+# Stores the server mode for metrics tracking.
+# Possible values:
+# - "tornado": Traditional Tornado server
+# - "starlette-managed": Starlette server via server.useStarlette config
+# - "starlette-app": st.App started via streamlit run
+# - "asgi-server": st.App with external ASGI server (uvicorn, gunicorn, etc.)
+# - "asgi-mounted": st.App mounted on another ASGI framework (FastAPI, Starlette)
+_server_mode: (
+    Literal[
+        "tornado", "starlette-managed", "starlette-app", "asgi-server", "asgi-mounted"
+    ]
+    | None
+) = None
+
 # Indicates that a config option was defined by the user.
 _USER_DEFINED: Final = "<user defined>"
 

{streamlit_nightly-1.52.3.dev20260107 → streamlit_nightly-1.52.3.dev20260109}/streamlit/connections/__init__.py

@@ -13,7 +13,10 @@
 # limitations under the License.
 
 from streamlit.connections.base_connection import BaseConnection
-from streamlit.connections.snowflake_connection import SnowflakeConnection
+from streamlit.connections.snowflake_connection import (
+    SnowflakeCallersRightsConnection,
+    SnowflakeConnection,
+)
 from streamlit.connections.snowpark_connection import SnowparkConnection
 from streamlit.connections.sql_connection import SQLConnection
 
@@ -23,6 +26,7 @@ __all__ = [
     "BaseConnection",
     "ExperimentalBaseConnection",
     "SQLConnection",
+    "SnowflakeCallersRightsConnection",
     "SnowflakeConnection",
     "SnowparkConnection",
 ]

{streamlit_nightly-1.52.3.dev20260107 → streamlit_nightly-1.52.3.dev20260109}/streamlit/connections/snowflake_connection.py

@@ -20,7 +20,8 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Final, cast
+import os
+from typing import TYPE_CHECKING, Any, Final, Literal, cast
 
 from streamlit import logger
 from streamlit.connections import BaseConnection
@@ -45,11 +46,18 @@ if TYPE_CHECKING:
 # (see docs: https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-api#id6)
 SQLSTATE_CONNECTION_WAS_NOT_ESTABLISHED: Final = "08001"
 
+# The location on disk where Snowpark Container Services will mount service connection tokens.
+SNOWPARK_CONNECTION_TOKEN_FILE = "/snowflake/session/token"  # noqa: S105 (not a password)
 
-class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
+# The header where Snowpark Container Services will put per-user connection tokens.
+SNOWPARK_USER_TOKEN_HEADER_NAME = "Sf-Context-Current-User-Token"  # noqa: S105 (not a password)
+
+
+class BaseSnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
     """A connection to Snowflake using the Snowflake Connector for Python.
 
-    Initialize this connection object using ``st.connection("snowflake")`` or
+    For standard connections, create an instance of this using
+    ``st.connection("snowflake")`` or
     ``st.connection("<name>", type="snowflake")``. Connection parameters for a
     SnowflakeConnection can be specified using ``secrets.toml`` and/or
     ``**kwargs``. Connection parameters are passed to
@@ -61,7 +69,14 @@ class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
     case. Use ``secrets.toml`` and ``**kwargs`` to configure your connection
     for local development.
 
-    SnowflakeConnection includes several convenience methods. For example, you
+    When an app is running in Snowpark Container Services and has caller's rights
+    enabled, ``st.connection("snowflake-callers-rights")`` connects automatically
+    using the current user's identity tokens. This will be a session-scoped connection
+    to ensure that the identity stays tied to the active user. Unlike with
+    ``"snowflake"`` connections, it will use the Snowpark Container Services connection
+    settings even when other ``**kwargs`` are provided.
+
+    BaseSnowflakeConnection includes several convenience methods. For example, you
     can directly execute a SQL query with ``.query()`` or access the underlying
     Snowflake Connector object with ``.raw_connection``.
 
@@ -85,6 +100,12 @@ class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
         in SQL queries. For more information, see `Account identifiers
         <https://docs.snowflake.com/en/user-guide/admin-account-identifier>`_.
 
+    .. Important::
+        Caller's rights connections rely on credentials provided when a user first
+        connects to a Streamlit app. These credentials are only valid for a short period
+        of time - so caller's rights connections must be created at the top of an app
+        or else the connection may fail.
+
     Examples
     --------
     **Example 1: Configuration with Streamlit secrets**
@@ -222,64 +243,23 @@ class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
     >>> conn = st.connection("snowflake")
     >>> df = conn.query("SELECT * FROM my_table")
 
-    """
+    **Example 7: Caller's rights connection when running in Snowpark Container Services**
 
-    def _connect(self, **kwargs: Any) -> InternalSnowflakeConnection:
-        import snowflake.connector  # type:ignore[import]
-        from snowflake.connector import Error as SnowflakeError  # type:ignore[import]
+    This connection will work for any Streamlit-in-Snowflake app using a container
+    runtime, as well as any self-managed caller's rights Service in Snowpark Container
+    Services that is hosting Streamlit.
 
-        # If we're running in SiS, just call get_active_session() and retrieve the
-        # lower-level connection from it.
-        if running_in_sis():
-            from snowflake.snowpark.context import (  # type:ignore[import]  # isort: skip
-                get_active_session,
-            )
-
-            session = get_active_session()
+    This will use the Snowpark-provided account, host, database, and schema to connect.
+    Additionally, it will set ``client_session_keep_alive`` to ``True``. These values
+    may be overridden with ``**kwargs``.
 
-            if hasattr(session, "connection"):
-                return session.connection
-            # session.connection is only a valid attr in more recent versions of
-            # snowflake-connector-python, so we fall back to grabbing
-            # session._conn._conn if `.connection` is unavailable.
-            return session._conn._conn
-
-        # We require qmark-style parameters everywhere for consistency across different
-        # environments where SnowflakeConnections may be used.
-        snowflake.connector.paramstyle = "qmark"
-
-        # Otherwise, attempt to create a new connection from whatever credentials we
-        # have available.
-        st_secrets = self._secrets.to_dict()
-        try:
-            if len(st_secrets):
-                _LOGGER.info(
-                    "Connect to Snowflake using the Streamlit secret defined under "
-                    "[connections.snowflake]."
-                )
-                conn_kwargs = {**st_secrets, **kwargs}
-                return snowflake.connector.connect(**conn_kwargs)
+    Your app code:
 
-            # Use the default configuration as defined in https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-a-default-connection
-            if self._connection_name == "snowflake":
-                _LOGGER.info(
-                    "Connect to Snowflake using the default configuration as defined "
-                    "in https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-a-default-connection"
-                )
-                return snowflake.connector.connect()
+    >>> import streamlit as st
+    >>> conn = st.connection("snowflake-callers-rights")
+    >>> df = conn.query("SELECT * FROM my_table")
 
-            return snowflake.connector.connect(**kwargs)
-        except SnowflakeError:
-            if not len(st_secrets) and not kwargs:
-                raise StreamlitAPIException(
-                    "Missing Snowflake connection configuration. "
-                    "Did you forget to set this in `secrets.toml`, a Snowflake configuration file, "
-                    "or as kwargs to `st.connection`? "
-                    "See the [SnowflakeConnection configuration documentation]"
-                    "(https://docs.streamlit.io/st.connections.snowflakeconnection-configuration) "
-                    "for more details and examples."
-                )
-            raise
+    """
 
     def query(
         self,
@@ -563,3 +543,169 @@ class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
         return cast(
             "Session", Session.builder.configs({"connection": self._instance}).create()
         )
+
+    def close(self) -> None:
+        """Closes the underlying Snowflake connection."""
+        if self._raw_instance is not None:
+            self._raw_instance.close()
+
+
+class SnowflakeConnection(BaseSnowflakeConnection):
+    """A connection to Snowflake using the Snowflake Connector for Python.
+
+    See ``BaseSnowflakeConnection`` for complete docs.
+    """
+
+    def _connect(self, **kwargs: Any) -> InternalSnowflakeConnection:
+        import snowflake.connector  # type:ignore[import]
+        from snowflake.connector import Error as SnowflakeError  # type:ignore[import]
+
+        # If we're running in SiS-on-warehouses, just call get_active_session() and
+        # retrieve the lower-level connection from it.
+        if running_in_sis():
+            from snowflake.snowpark.context import (  # type:ignore[import]  # isort: skip
+                get_active_session,
+            )
+
+            session = get_active_session()
+
+            if hasattr(session, "connection"):
+                return session.connection
+            # session.connection is only a valid attr in more recent versions of
+            # snowflake-connector-python, so we fall back to grabbing
+            # session._conn._conn if `.connection` is unavailable.
+            return session._conn._conn
+
+        # We require qmark-style parameters everywhere for consistency across different
+        # environments where SnowflakeConnections may be used.
+        snowflake.connector.paramstyle = "qmark"
+
+        # Otherwise, attempt to create a new connection from whatever credentials we
+        # have available.
+        st_secrets = self._secrets.to_dict()
+        try:
+            if len(st_secrets):
+                _LOGGER.info(
+                    "Connect to Snowflake using the Streamlit secret defined under "
+                    "[connections.snowflake]."
+                )
+                conn_kwargs = {**st_secrets, **kwargs}
+                return snowflake.connector.connect(**conn_kwargs)
+
+            # Use the default configuration as defined in https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-a-default-connection
+            if self._connection_name == "snowflake":
+                _LOGGER.info(
+                    "Connect to Snowflake using the default configuration as defined "
+                    "in https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-a-default-connection"
+                )
+                return snowflake.connector.connect()
+
+            return snowflake.connector.connect(**kwargs)
+        except SnowflakeError:
+            if not len(st_secrets) and not kwargs:
+                raise StreamlitAPIException(
+                    "Missing Snowflake connection configuration. "
+                    "Did you forget to set this in `secrets.toml`, a Snowflake configuration file, "
+                    "or as kwargs to `st.connection`? "
+                    "See the [SnowflakeConnection configuration documentation]"
+                    "(https://docs.streamlit.io/st.connections.snowflakeconnection-configuration) "
+                    "for more details and examples."
+                )
+            raise
+
+
+class SnowflakeCallersRightsConnection(SnowflakeConnection):
+    """A caller's rights connection to Snowflake using the Snowflake Connector for Python.
+
+    This will only work when running on Snowpark Container Services or another
+    compatible platform.
+
+    See ``BaseSnowflakeConnection`` for complete docs.
+    """
+
+    @classmethod
+    def scope(cls) -> Literal["session"]:
+        """Returns ``"session"``.
+
+        Caller's rights Snowflake connections rely on per-session connection tokens and
+        therefore must be session-scoped.
+        """
+        return "session"
+
+    @classmethod
+    def _read_token_file(cls) -> str:
+        """Returns the contents of the Snowpark token file on disk."""
+        with open(SNOWPARK_CONNECTION_TOKEN_FILE) as token_file:
+            return token_file.read()
+
+    @classmethod
+    def _get_connection_params(cls) -> dict[str, str | bool]:
+        """Returns caller's rights connection parameters for the current session.
+
+        Raises
+        ------
+            StreamlitAPIException: if any Snowpark environment variables or connection
+            tokens are missing; or if this is called outside of a session context.
+        """
+        # Local import needed to avoid cycles.
+        from streamlit import context as st_context
+
+        # See Snowflake docs:
+        # https://docs.snowflake.com/en/developer-guide/snowpark-container-services/additional-considerations-services-jobs#configuring-caller-s-rights-for-your-service
+
+        # Base parameters, common to all connections.
+        params: dict[str, str | bool] = {
+            "authenticator": "oauth",
+            # OCSP checks do not work in Snowflake containers.
+            "ocsp_fail_open": True,
+            # We want to keep this alive, as the user token will expire fairly quickly
+            # - so we can't create a new session on expiration.
+            "client_session_keep_alive": True,
+        }
+        for param_name, env_var_name in (
+            ("account", "SNOWFLAKE_ACCOUNT"),
+            ("host", "SNOWFLAKE_HOST"),
+            ("database", "SNOWFLAKE_DATABASE"),
+            ("schema", "SNOWFLAKE_SCHEMA"),
+        ):
+            value = os.getenv(env_var_name)
+            if value is None:
+                raise StreamlitAPIException(
+                    f"Environment variable `{env_var_name}` not found. Is this app "
+                    "running in a Snowflake container environment?"
+                )
+            params[param_name] = value
+
+        # Validate the token file exists, and read it.
+        if not os.path.exists(SNOWPARK_CONNECTION_TOKEN_FILE):
+            raise StreamlitAPIException(
+                f"Token file `{SNOWPARK_CONNECTION_TOKEN_FILE}` not found. Is this app "
+                "running in a Snowflake container environment?"
+            )
+        login_token = cls._read_token_file()
+
+        # Validate the token header exists, and read it.
+        if SNOWPARK_USER_TOKEN_HEADER_NAME not in st_context.headers:
+            raise StreamlitAPIException(
+                "Token header not found. Is this app running with caller's "
+                "rights enabled, and is this connection being created in an app "
+                "execution thread?"
+            )
+        user_token = st_context.headers[SNOWPARK_USER_TOKEN_HEADER_NAME]
+
+        # Build the actual caller's rights token.
+        params["token"] = f"{login_token}.{user_token}"
+
+        return params
+
+    def _connect(self, **kwargs: Any) -> InternalSnowflakeConnection:
+        import snowflake.connector  # type:ignore[import]
+
+        # We require qmark-style parameters everywhere for consistency across different
+        # environments where SnowflakeConnections may be used.
+        snowflake.connector.paramstyle = "qmark"
+
+        params = self._get_connection_params()
+
+        # Connect with the params we generated, overriding with user-specified params.
+        return snowflake.connector.connect(**{**params, **kwargs})

{streamlit_nightly-1.52.3.dev20260107 → streamlit_nightly-1.52.3.dev20260109}/streamlit/elements/lib/options_selector_utils.py

@@ -20,6 +20,7 @@ from typing import TYPE_CHECKING, Any, Final, TypeVar, overload
 from streamlit import config, logger
 from streamlit.dataframe_util import OptionSequence, convert_anything_to_list
 from streamlit.errors import StreamlitAPIException
+from streamlit.runtime.state import get_session_state
 from streamlit.runtime.state.common import RegisterWidgetResult
 from streamlit.type_util import (
     check_python_comparable,
@@ -282,3 +283,100 @@ def create_mappings(
         formatted_options,
         formatted_option_to_option_mapping,
     )
+
+
+def validate_and_sync_value_with_options(
+    current_value: T | None,
+    opt: Sequence[T],
+    default_index: int | None,
+    key: str | int | None,
+) -> tuple[T | None, bool]:
+    """Validate current value against options, resetting session state if invalid.
+
+    This function has a side-effect: if the value is not found in the options
+    and a key is provided, it will update session state with the new value.
+
+    Parameters
+    ----------
+    current_value
+        The current widget value to validate.
+    opt
+        The sequence of valid options.
+    default_index
+        The default index to reset to if value is invalid.
+    key
+        The widget key for session state updates.
+
+    Returns
+    -------
+    tuple[T | None, bool]
+        A tuple of (validated_value, value_was_reset).
+    """
+    if current_value is None:
+        return current_value, False
+
+    # Check if current value is still in the new options
+    try:
+        index_(opt, current_value)
+        return current_value, False
+    except ValueError:
+        # Value not in options - reset to default
+        if default_index is not None and len(opt) > 0:
+            new_value: T | None = opt[default_index]
+        else:
+            new_value = None
+
+        if key is not None:
+            # Update session_state so subsequent accesses in this run
+            # return the corrected value. Use reset_state_value to avoid
+            # the "cannot be modified after widget instantiated" error.
+            get_session_state().reset_state_value(str(key), new_value)
+
+        return new_value, True
+
+
+def validate_and_sync_multiselect_value_with_options(
+    current_values: list[T] | list[T | str],
+    opt: Sequence[T],
+    key: str | int | None,
+) -> tuple[list[T] | list[T | str], bool]:
+    """Validate multiselect values against options, syncing session state if needed.
+
+    This function has a side-effect: if any values are filtered out and a key
+    is provided, it will update session state with the filtered list.
+
+    Unlike selectbox which resets to a default when the value is invalid,
+    multiselect filters out invalid values and keeps the valid ones.
+
+    Parameters
+    ----------
+    current_values
+        The current list of selected values to validate.
+    opt
+        The sequence of valid options.
+    key
+        The widget key for session state updates.
+
+    Returns
+    -------
+    tuple[list[T] | list[T | str], bool]
+        A tuple of (validated_values, values_were_filtered).
+    """
+    if not current_values:
+        return current_values, False
+
+    valid_values: list[T | str] = []
+    for value in current_values:
+        try:
+            index_(opt, value)
+            valid_values.append(value)
+        except ValueError:  # noqa: PERF203
+            pass
+
+    if len(valid_values) == len(current_values):
+        return current_values, False
+
+    if key is not None:
+        get_session_state().reset_state_value(str(key), valid_values)
+
+    return valid_values, True

{streamlit_nightly-1.52.3.dev20260107 → streamlit_nightly-1.52.3.dev20260109}/streamlit/elements/widgets/multiselect.py

@@ -38,6 +38,7 @@ from streamlit.elements.lib.options_selector_utils import (
     create_mappings,
     get_default_indices,
     maybe_coerce_enum_sequence,
+    validate_and_sync_multiselect_value_with_options,
 )
 from streamlit.elements.lib.policies import (
     check_widget_policies,
@@ -493,15 +494,9 @@ class MultiSelectMixin:
         element_id = compute_and_register_element_id(
             widget_name,
             user_key=key,
-            # Treat the provided key as the main identity. Only include
-            # changes to the options, accept_new_options, and max_selections
-            # in the identity computation as those can invalidate the
-            # current selection.
             key_as_main_identity={
-                "options",
                 "max_selections",
                 "accept_new_options",
-                "format_func",
             },
             dg=self.dg,
             label=label,
@@ -554,8 +549,23 @@ class MultiSelectMixin:
             widget_state, options, indexable_options
         )
 
-        if widget_state.value_changed:
-            proto.raw_values[:] = serde.serialize(widget_state.value)
+        if accept_new_options:
+            # accept_new_options is True, so we keep the user-entered values.
+            current_values = widget_state.value
+            value_needs_reset = False
+        else:
+            # Validate the current values against the new options.
+            # If values are no longer valid (not in options), filter them out.
+            # This handles the case where options change dynamically and the
+            # previously selected values are no longer available.
+            current_values, value_needs_reset = (
+                validate_and_sync_multiselect_value_with_options(
+                    widget_state.value, indexable_options, key
+                )
+            )
+
+        if value_needs_reset or widget_state.value_changed:
+            proto.raw_values[:] = serde.serialize(current_values)
             proto.set_value = True
 
         validate_width(width)
@@ -566,7 +576,7 @@ class MultiSelectMixin:
 
         self.dg._enqueue(widget_name, proto, layout_config=layout_config)
 
-        return widget_state.value
+        return current_values
 
     @property
     def dg(self) -> DeltaGenerator:

{streamlit_nightly-1.52.3.dev20260107 → streamlit_nightly-1.52.3.dev20260109}/streamlit/elements/widgets/selectbox.py

@@ -37,6 +37,7 @@ from streamlit.elements.lib.options_selector_utils import (
     create_mappings,
     index_,
     maybe_coerce_enum,
+    validate_and_sync_value_with_options,
 )
 from streamlit.elements.lib.policies import (
     check_widget_policies,
@@ -595,30 +596,17 @@ class SelectboxMixin:
         )
         widget_state = maybe_coerce_enum(widget_state, options, opt)
 
-        # Validate the current value against the new options.
-        # If the value is no longer valid (not in options), reset to default.
-        # This handles the case where options change dynamically and the
-        # previously selected value is no longer available.
-        current_value = widget_state.value
-        value_needs_reset = False
-
-        if current_value is not None and not accept_new_options:
-            # Check if current value is still in the new options
-            try:
-                index_(opt, current_value)
-            except ValueError:
-                # Value not in options - reset to default.
-                value_needs_reset = True
-                if index is not None and len(opt) > 0:
-                    current_value = opt[index]
-                else:
-                    current_value = None
-
-                # Update session_state so subsequent accesses in this run
-                # return the corrected value. Use reset_state_value to avoid
-                # the "cannot be modified after widget instantiated" error.
-                if key is not None:
-                    get_session_state().reset_state_value(key, current_value)
+        if accept_new_options:
+            current_value = widget_state.value
+            value_needs_reset = False
+        else:
+            # Validate the current value against the new options.
+            # If the value is no longer valid (not in options), reset to default.
+            # This handles the case where options change dynamically and the
+            # previously selected value is no longer available.
+            current_value, value_needs_reset = validate_and_sync_value_with_options(
+                widget_state.value, opt, index, key
+            )
 
         if value_needs_reset or widget_state.value_changed:
             serialized_value = serde.serialize(current_value)