[VoiceLive]Add NoTurnDetection to disable turn detection

sdk/ai/azure-ai-voicelive/CHANGELOG.md

@@ -1,34 +1,25 @@
 # Release History
 
-## 1.2.0 (2025-12-10)
+## 1.2.0b3 (Unreleased)
 
 ### Features Added
 
-- **MCP (Model Context Protocol) Support**: Added comprehensive support for Model Context Protocol integration:
-  - `MCPServer` tool type for defining MCP server configurations with authorization, headers, and approval requirements
-  - `MCPTool` model for representing MCP tool definitions with input schemas and annotations
-  - `MCPApprovalType` enum for controlling approval workflows (`never`, `always`, or tool-specific)
-  - New item types: `MCPApprovalResponseRequestItem`, `ResponseMCPApprovalRequestItem`, `ResponseMCPApprovalResponseItem`, `ResponseMCPCallItem`, and `ResponseMCPListToolItem`
-  - New server events: `ServerEventMcpListToolsInProgress`, `ServerEventMcpListToolsCompleted`, `ServerEventMcpListToolsFailed`, `ServerEventResponseMcpCallArgumentsDelta`, `ServerEventResponseMcpCallArgumentsDone`, `ServerEventResponseMcpCallInProgress`, `ServerEventResponseMcpCallCompleted`, and `ServerEventResponseMcpCallFailed`
-  - Client event `MCP_APPROVAL_RESPONSE` for responding to approval requests
-  - Enhanced `ItemType` enum with MCP-related types: `mcp_list_tools`, `mcp_call`, `mcp_approval_request`, and `mcp_approval_response`
-- **Enhanced Avatar Configuration**: Expanded avatar functionality with new configuration options:
-  - Added `AvatarConfigTypes` enum with support for `video-avatar` and `photo-avatar` types
-  - Added `PhotoAvatarBaseModes` enum for photo avatar base models (e.g., `vasa-1`)
-  - Added `AvatarOutputProtocol` enum for avatar streaming protocols (`webrtc`, `websocket`)
-  - Enhanced `AvatarConfig` model with new properties: `type`, `model`, and `output_protocol`
-- **Image Content Support**: Added support for image inputs in conversations:
-  - New `RequestImageContentPart` model for including images in requests
-  - New `RequestImageContentPartDetail` enum for controlling image detail levels (`auto`, `low`, `high`)
-  - Added `INPUT_IMAGE` to `ContentPartType` enum
-  - Enhanced token details models (`InputTokenDetails`, `CachedTokenDetails`) with `image_tokens` tracking
-- **Enhanced OpenAI Voices**: Added new OpenAI voice options:
-  - Added `marin` and `cedar` voices to `OpenAIVoiceName` enum
-- **Extended Azure Personal Voice Configuration**: Enhanced `AzurePersonalVoice` with additional customization options:
-  - Added support for custom lexicon via `custom_lexicon_url`
-  - Added `prefer_locales` for locale preferences
-  - Added `locale`, `style`, `pitch`, `rate`, and `volume` properties for fine-tuned voice control
-- **Pre-generated Assistant Messages**: Added support for pre-generated assistant messages in `ResponseCreateParams` via the `pre_generated_assistant_message` property
+- **Manual Turn Taking Control**: Added `NoTurnDetection` class to allow manual control of turn taking
+  - `TurnDetectionType.NONE` enum value for explicitly disabling automatic turn detection
+  - Enables client-managed conversation flow without server-side voice activity detection
+- **Array Encoding Support**: Enhanced model serialization to support delimited string arrays
+  - Support for pipe-delimited, space-delimited, comma-delimited, and newline-delimited array formats
+  - Automatic encoding/decoding of string arrays to delimited strings in model properties
+
+### Other Changes
+
+- **Security Enhancement**: Replaced `eval()` usage in serialization code with explicit type checking
+- **Dependency Update**: Updated `azure-core` minimum version requirement from `1.35.0` to `1.36.0`
+- **Development Status**: Reverted package development status to Beta (was incorrectly set to Production/Stable)
+
+### Bug Fixes
+
+- Fixed deserialization handling for mutable types (dict, list, set) to properly track changes in model objects
 
 ## 1.2.0b2 (2025-11-20)
 

sdk/ai/azure-ai-voicelive/apiview-properties.json

@@ -57,6 +57,7 @@
         "azure.ai.voicelive.models.MCPApprovalResponseRequestItem": "VoiceLive.MCPApprovalResponseRequestItem",
         "azure.ai.voicelive.models.MCPServer": "VoiceLive.MCPServer",
         "azure.ai.voicelive.models.MCPTool": "VoiceLive.MCPTool",
+        "azure.ai.voicelive.models.NoTurnDetection": "VoiceLive.NoTurnDetection",
         "azure.ai.voicelive.models.OpenAIVoice": "VoiceLive.OpenAIVoice",
         "azure.ai.voicelive.models.OutputTextContentPart": "VoiceLive.OutputTextContentPart",
         "azure.ai.voicelive.models.OutputTokenDetails": "VoiceLive.OutputTokenDetails",

sdk/ai/azure-ai-voicelive/azure/ai/voicelive/_utils/model_base.py

@@ -171,6 +171,21 @@ def default(self, o):  # pylint: disable=too-many-return-statements
     r"(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{4}\s\d{2}:\d{2}:\d{2}\sGMT"
 )
 
+_ARRAY_ENCODE_MAPPING = {
+    "pipeDelimited": "|",
+    "spaceDelimited": " ",
+    "commaDelimited": ",",
+    "newlineDelimited": "\n",
+}
+
+
+def _deserialize_array_encoded(delimit: str, attr):
+    if isinstance(attr, str):
+        if attr == "":
+            return []
+        return attr.split(delimit)
+    return attr
+
 
 def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime:
     """Deserialize ISO-8601 formatted string into Datetime object.
@@ -315,6 +330,8 @@ def _deserialize_int_as_str(attr):
 def get_deserializer(annotation: typing.Any, rf: typing.Optional["_RestField"] = None):
     if annotation is int and rf and rf._format == "str":
         return _deserialize_int_as_str
+    if annotation is str and rf and rf._format in _ARRAY_ENCODE_MAPPING:
+        return functools.partial(_deserialize_array_encoded, _ARRAY_ENCODE_MAPPING[rf._format])
     if rf and rf._format:
         return _DESERIALIZE_MAPPING_WITHFORMAT.get(rf._format)
     return _DESERIALIZE_MAPPING.get(annotation)  # pyright: ignore
@@ -353,9 +370,39 @@ def __contains__(self, key: typing.Any) -> bool:
         return key in self._data
 
     def __getitem__(self, key: str) -> typing.Any:
+        # If this key has been deserialized (for mutable types), we need to handle serialization
+        if hasattr(self, "_attr_to_rest_field"):
+            cache_attr = f"_deserialized_{key}"
+            if hasattr(self, cache_attr):
+                rf = _get_rest_field(getattr(self, "_attr_to_rest_field"), key)
+                if rf:
+                    value = self._data.get(key)
+                    if isinstance(value, (dict, list, set)):
+                        # For mutable types, serialize and return
+                        # But also update _data with serialized form and clear flag
+                        # so mutations via this returned value affect _data
+                        serialized = _serialize(value, rf._format)
+                        # If serialized form is same type (no transformation needed),
+                        # return _data directly so mutations work
+                        if isinstance(serialized, type(value)) and serialized == value:
+                            return self._data.get(key)
+                        # Otherwise return serialized copy and clear flag
+                        try:
+                            object.__delattr__(self, cache_attr)
+                        except AttributeError:
+                            pass
+                        # Store serialized form back
+                        self._data[key] = serialized
+                        return serialized
         return self._data.__getitem__(key)
 
     def __setitem__(self, key: str, value: typing.Any) -> None:
+        # Clear any cached deserialized value when setting through dictionary access
+        cache_attr = f"_deserialized_{key}"
+        try:
+            object.__delattr__(self, cache_attr)
+        except AttributeError:
+            pass
         self._data.__setitem__(key, value)
 
     def __delitem__(self, key: str) -> None:
@@ -483,6 +530,8 @@ def _is_model(obj: typing.Any) -> bool:
 
 def _serialize(o, format: typing.Optional[str] = None):  # pylint: disable=too-many-return-statements
     if isinstance(o, list):
+        if format in _ARRAY_ENCODE_MAPPING and all(isinstance(x, str) for x in o):
+            return _ARRAY_ENCODE_MAPPING[format].join(o)
         return [_serialize(x, format) for x in o]
     if isinstance(o, dict):
         return {k: _serialize(v, format) for k, v in o.items()}
@@ -767,6 +816,17 @@ def _deserialize_sequence(
         return obj
     if isinstance(obj, ET.Element):
         obj = list(obj)
+    try:
+        if (
+            isinstance(obj, str)
+            and isinstance(deserializer, functools.partial)
+            and isinstance(deserializer.args[0], functools.partial)
+            and deserializer.args[0].func == _deserialize_array_encoded  # pylint: disable=comparison-with-callable
+        ):
+            # encoded string may be deserialized to sequence
+            return deserializer(obj)
+    except:  # pylint: disable=bare-except
+        pass
     return type(obj)(_deserialize(deserializer, entry, module) for entry in obj)
 
 
@@ -998,7 +1058,11 @@ def __init__(
 
     @property
     def _class_type(self) -> typing.Any:
-        return getattr(self._type, "args", [None])[0]
+        result = getattr(self._type, "args", [None])[0]
+        # type may be wrapped by nested functools.partial so we need to check for that
+        if isinstance(result, functools.partial):
+            return getattr(result, "args", [None])[0]
+        return result
 
     @property
     def _rest_name(self) -> str:
@@ -1009,14 +1073,37 @@ def _rest_name(self) -> str:
     def __get__(self, obj: Model, type=None):  # pylint: disable=redefined-builtin
         # by this point, type and rest_name will have a value bc we default
         # them in __new__ of the Model class
-        item = obj.get(self._rest_name)
+        # Use _data.get() directly to avoid triggering __getitem__ which clears the cache
+        item = obj._data.get(self._rest_name)
         if item is None:
             return item
         if self._is_model:
             return item
-        return _deserialize(self._type, _serialize(item, self._format), rf=self)
+
+        # For mutable types, we want mutations to directly affect _data
+        # Check if we've already deserialized this value
+        cache_attr = f"_deserialized_{self._rest_name}"
+        if hasattr(obj, cache_attr):
+            # Return the value from _data directly (it's been deserialized in place)
+            return obj._data.get(self._rest_name)
+
+        deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self)
+
+        # For mutable types, store the deserialized value back in _data
+        # so mutations directly affect _data
+        if isinstance(deserialized, (dict, list, set)):
+            obj._data[self._rest_name] = deserialized
+            object.__setattr__(obj, cache_attr, True)  # Mark as deserialized
+            return deserialized
+
+        return deserialized
 
     def __set__(self, obj: Model, value) -> None:
+        # Clear the cached deserialized object when setting a new value
+        cache_attr = f"_deserialized_{self._rest_name}"
+        if hasattr(obj, cache_attr):
+            object.__delattr__(obj, cache_attr)
+
         if value is None:
             # we want to wipe out entries if users set attr to None
             try:

sdk/ai/azure-ai-voicelive/azure/ai/voicelive/_utils/serialization.py

@@ -821,13 +821,20 @@ def serialize_basic(cls, data, data_type, **kwargs):
         :param str data_type: Type of object in the iterable.
         :rtype: str, int, float, bool
         :return: serialized object
+        :raises TypeError: raise if data_type is not one of str, int, float, bool.
         """
         custom_serializer = cls._get_custom_serializers(data_type, **kwargs)
         if custom_serializer:
             return custom_serializer(data)
         if data_type == "str":
             return cls.serialize_unicode(data)
-        return eval(data_type)(data)  # nosec # pylint: disable=eval-used
+        if data_type == "int":
+            return int(data)
+        if data_type == "float":
+            return float(data)
+        if data_type == "bool":
+            return bool(data)
+        raise TypeError("Unknown basic data type: {}".format(data_type))
 
     @classmethod
     def serialize_unicode(cls, data):
@@ -1757,7 +1764,7 @@ def deserialize_basic(self, attr, data_type):  # pylint: disable=too-many-return
         :param str data_type: deserialization data type.
         :return: Deserialized basic type.
         :rtype: str, int, float or bool
-        :raises TypeError: if string format is not valid.
+        :raises TypeError: if string format is not valid or data_type is not one of str, int, float, bool.
         """
         # If we're here, data is supposed to be a basic type.
         # If it's still an XML node, take the text
@@ -1783,7 +1790,11 @@ def deserialize_basic(self, attr, data_type):  # pylint: disable=too-many-return
 
         if data_type == "str":
             return self.deserialize_unicode(attr)
-        return eval(data_type)(attr)  # nosec # pylint: disable=eval-used
+        if data_type == "int":
+            return int(attr)
+        if data_type == "float":
+            return float(attr)
+        raise TypeError("Unknown basic data type: {}".format(data_type))
 
     @staticmethod
     def deserialize_unicode(data):

sdk/ai/azure-ai-voicelive/azure/ai/voicelive/_version.py

@@ -6,4 +6,4 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-VERSION = "1.2.0"
+VERSION = "1.2.0b3"

sdk/ai/azure-ai-voicelive/azure/ai/voicelive/models/__init__.py

@@ -68,6 +68,7 @@
     MCPTool,
     MessageContentPart,
     MessageItem,
+    NoTurnDetection,
     OpenAIVoice,
     OutputTextContentPart,
     OutputTokenDetails,
@@ -238,6 +239,7 @@
     "MCPTool",
     "MessageContentPart",
     "MessageItem",
+    "NoTurnDetection",
     "OpenAIVoice",
     "OutputTextContentPart",
     "OutputTokenDetails",

sdk/ai/azure-ai-voicelive/azure/ai/voicelive/models/_enums.py

@@ -325,6 +325,7 @@ class ToolType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
 class TurnDetectionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     """Type of TurnDetectionType."""
 
+    NONE = "none"
     SERVER_VAD = "server_vad"
     AZURE_SEMANTIC_VAD = "azure_semantic_vad"
     AZURE_SEMANTIC_VAD_EN = "azure_semantic_vad_en"

sdk/ai/azure-ai-voicelive/azure/ai/voicelive/models/_models.py

@@ -777,17 +777,17 @@ class TurnDetection(_Model):
     """Top-level union for turn detection configuration.
 
     You probably want to use the sub-classes and not this class directly. Known sub-classes are:
-    AzureSemanticVad, AzureSemanticVadEn, AzureSemanticVadMultilingual, ServerVad
+    AzureSemanticVad, AzureSemanticVadEn, AzureSemanticVadMultilingual, NoTurnDetection, ServerVad
 
-    :ivar type: Required. Known values are: "server_vad", "azure_semantic_vad",
+    :ivar type: Required. Known values are: "none", "server_vad", "azure_semantic_vad",
      "azure_semantic_vad_en", and "azure_semantic_vad_multilingual".
     :vartype type: str or ~azure.ai.voicelive.models.TurnDetectionType
     """
 
     __mapping__: dict[str, _Model] = {}
     type: str = rest_discriminator(name="type", visibility=["read", "create", "update", "delete", "query"])
-    """Required. Known values are: \"server_vad\", \"azure_semantic_vad\", \"azure_semantic_vad_en\",
-     and \"azure_semantic_vad_multilingual\"."""
+    """Required. Known values are: \"none\", \"server_vad\", \"azure_semantic_vad\",
+     \"azure_semantic_vad_en\", and \"azure_semantic_vad_multilingual\"."""
 
     @overload
     def __init__(
@@ -2489,6 +2489,33 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
+class NoTurnDetection(TurnDetection, discriminator="none"):
+    """No turn detection - client manages turn taking.
+
+    :ivar type: Required.
+    :vartype type: str or ~azure.ai.voicelive.models.NONE
+    """
+
+    type: Literal[TurnDetectionType.NONE] = rest_discriminator(name="type", visibility=["read", "create", "update", "delete", "query"])  # type: ignore
+    """Required."""
+
+    @overload
+    def __init__(
+        self,
+    ) -> None: ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.type = TurnDetectionType.NONE  # type: ignore
+
+
 class OpenAIVoice(_Model):
     """OpenAI voice configuration with explicit type field.
 
@@ -2681,8 +2708,6 @@ class RequestSession(_Model):
     :vartype instructions: str
     :ivar input_audio_sampling_rate: Input audio sampling rate in Hz. Available values:
 
-
-
      * For pcm16: 8000, 16000, 24000
 
      * For g711_alaw/g711_ulaw: 8000.
@@ -2737,8 +2762,6 @@ class RequestSession(_Model):
     input_audio_sampling_rate: Optional[int] = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """Input audio sampling rate in Hz. Available values:
 
-
-
       * For pcm16: 8000, 16000, 24000
 
       * For g711_alaw/g711_ulaw: 8000."""
@@ -3733,8 +3756,6 @@ class ResponseSession(_Model):
     :vartype instructions: str
     :ivar input_audio_sampling_rate: Input audio sampling rate in Hz. Available values:
 
-
-
      * For pcm16: 8000, 16000, 24000
 
      * For g711_alaw/g711_ulaw: 8000.
@@ -3793,8 +3814,6 @@ class ResponseSession(_Model):
     input_audio_sampling_rate: Optional[int] = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """Input audio sampling rate in Hz. Available values:
 
-
-
       * For pcm16: 8000, 16000, 24000
 
       * For g711_alaw/g711_ulaw: 8000."""

sdk/ai/azure-ai-voicelive/pyproject.toml

@@ -17,7 +17,7 @@ authors = [
 description = "Microsoft Corporation Azure Ai Voicelive Client Library for Python"
 license = "MIT"
 classifiers = [
-    "Development Status :: 5 - Production/Stable",
+    "Development Status :: 4 - Beta",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3 :: Only",
     "Programming Language :: Python :: 3",
@@ -32,7 +32,7 @@ keywords = ["azure", "azure sdk"]
 
 dependencies = [
     "isodate>=0.6.1",
-    "azure-core>=1.35.0",
+    "azure-core>=1.36.0",
     "typing-extensions>=4.6.0",
 ]
 dynamic = [