volcengine-python-sdk 4.0.28__py2.py3-none-any.whl → 4.0.30__py2.py3-none-any.whl

volcenginesdkarkruntime/resources/encryption.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+from .._constants import ARK_E2E_ENCRYPTION_HEADER
+from .._streaming import Stream, AsyncStream
+from ..types.chat import (
+    ChatCompletion,
+    ChatCompletionChunk,
+)
+
+import os
+import json
+import warnings
+from copy import deepcopy
+from urllib.parse import urlparse
+from typing import (
+    Union,
+    Iterable,
+    Callable,
+    Iterator,
+    AsyncIterator,
+)
+
+from .._utils._key_agreement import aes_gcm_decrypt_base64_string, aes_gcm_decrypt_base64_list, decrypt_validate
+
+
+def _decrypt_chunk(
+    key: bytes, nonce: bytes, resp: Stream[ChatCompletionChunk]
+) -> Iterator[ChatCompletionChunk]:
+    for chunk in resp:
+        if chunk.choices is not None:
+            for index, choice in enumerate(chunk.choices):
+                if (
+                    choice.delta is not None and choice.delta.content is not None
+                    and choice.finish_reason != 'content_filter'
+                ):
+                    choice.delta.content = aes_gcm_decrypt_base64_string(
+                        key, nonce, choice.delta.content
+                    )
+                chunk.choices[index] = choice
+        yield chunk
+
+
+async def _async_decrypt_chunk(
+    key: bytes, nonce: bytes, resp: AsyncStream[ChatCompletionChunk]
+) -> AsyncIterator[ChatCompletionChunk]:
+    async for chunk in resp:
+        if chunk.choices is not None:
+            for index, choice in enumerate(chunk.choices):
+                if (
+                    choice.delta is not None and choice.delta.content is not None
+                    and choice.finish_reason != 'content_filter'
+                ):
+                    choice.delta.content = aes_gcm_decrypt_base64_string(
+                        key, nonce, choice.delta.content
+                    )
+                chunk.choices[index] = choice
+        yield chunk
+
+
+def _decrypt(
+    key: bytes,
+    nonce: bytes,
+    resp: Union[ChatCompletion, Stream[ChatCompletionChunk]]
+) -> ChatCompletion | Stream[ChatCompletionChunk]:
+    if isinstance(resp, ChatCompletion):
+        if resp.choices is not None:
+            for index, choice in enumerate(resp.choices):
+                if (
+                    choice.message is not None and choice.finish_reason != 'content_filter'
+                    and choice.message.content is not None
+                ):
+                    try:
+                        content = aes_gcm_decrypt_base64_string(
+                            key, nonce, choice.message.content
+                        )
+                    except Exception:
+                        content = ''
+                    if content == '' or not decrypt_validate(choice.message.content):
+                        content = aes_gcm_decrypt_base64_list(
+                            key, nonce, choice.message.content
+                        )
+                    choice.message.content = content
+                resp.choices[index] = choice
+        return resp
+    else:
+        return Stream._make_stream_from_iterator(
+            _decrypt_chunk(key, nonce, resp)
+        )
+
+
+async def _async_decrypt(
+    key: bytes,
+    nonce: bytes,
+    resp: ChatCompletion | AsyncStream[ChatCompletionChunk],
+) -> ChatCompletion | AsyncStream[ChatCompletionChunk]:
+    if isinstance(resp, ChatCompletion):
+        if resp.choices is not None:
+            for index, choice in enumerate(resp.choices):
+                if (
+                    choice.message is not None and choice.finish_reason != 'content_filter'
+                    and choice.message.content is not None
+                ):
+                    try:
+                        content = aes_gcm_decrypt_base64_string(
+                            key, nonce, choice.message.content
+                        )
+                    except Exception:
+                        content = ''
+                    if content == '' or not decrypt_validate(choice.message.content):
+                        content = aes_gcm_decrypt_base64_list(
+                            key, nonce, choice.message.content
+                        )
+                    choice.message.content = content
+                resp.choices[index] = choice
+        return resp
+    else:
+        return AsyncStream._make_stream_from_iterator(
+            _async_decrypt_chunk(key, nonce, resp)
+        )
+
+
+def with_e2e_encryption(func):
+    def wrapper(*args, **kwargs):
+        is_encrypt, _crypto_key, _crypto_nonce = _content_encryption(
+            args, kwargs)
+        resp = func(*args, **kwargs)
+        if is_encrypt:
+            resp = _decrypt(_crypto_key, _crypto_nonce, resp)
+        return resp
+
+    return wrapper
+
+
+def async_with_e2e_encryption(func):
+    async def wrapper(*args, **kwargs):
+        is_encrypt, _crypto_key, _crypto_nonce = _content_encryption(
+            args, kwargs)
+        resp = await func(*args, **kwargs)
+        if is_encrypt:
+            resp = await _async_decrypt(_crypto_key, _crypto_nonce, resp)
+        return resp
+
+    return wrapper
+
+
+def _content_encryption(args, kwargs):
+    assert len(args) > 0
+    extra_headers = (
+        kwargs.get("extra_headers") if kwargs.get("extra_headers") else {}
+    )
+    if (
+        extra_headers is not None
+        and extra_headers.get(ARK_E2E_ENCRYPTION_HEADER, None) == "true"
+    ):
+        model: str = kwargs.get("model", "")
+        messages = deepcopy(kwargs["messages"])
+        ark_client = args[0]._client
+        client, ring_id, key_id, exp_time = ark_client._get_endpoint_certificate(
+            model)
+        _crypto_key, _crypto_nonce, session_token = client.generate_ecies_key_pair()
+        extra_headers["X-Session-Token"] = session_token
+        _process_messages(
+            messages,
+            lambda x: client.encrypt_string_with_key(
+                _crypto_key, _crypto_nonce, x),
+        )
+        info = {"ExpireTime": exp_time}
+        if os.environ.get("VOLC_ARK_ENCRYPTION") == "AICC":
+            info["Version"] = 'AICCv0.1'
+            info["KeyID"] = key_id
+            info["RingID"] = ring_id
+        extra_headers["X-Encrypt-Info"] = json.dumps(info)
+        kwargs["extra_headers"] = {**extra_headers}
+        kwargs["messages"] = messages
+        return True, _crypto_key, _crypto_nonce
+    return False, None, None
+
+
+def _process_messages(
+    messages, f: Callable[[str], str]
+):
+    for message in messages:
+        if message.get("content", None) is not None:
+            current_content = message.get("content")
+            if isinstance(current_content, str):
+                message["content"] = f(current_content)
+            elif isinstance(current_content, Iterable):
+                for part in current_content:
+                    if part.get("type", None) == "text":
+                        part["text"] = f(part["text"])
+                    elif part.get("type", None) == "image_url":
+                        parse_result = urlparse(part["image_url"]["url"])
+                        if parse_result.scheme == 'data':
+                            part["image_url"]["url"] = f(
+                                part["image_url"]["url"])
+                        elif parse_result.scheme == 'http' or parse_result.scheme == 'https':
+                            warnings.warn(
+                                "encryption is not supported for image url, "
+                                "please use base64 image if you want encryption"
+                            )
+                        else:
+                            raise TypeError(
+                                "encryption is not supported for image url scheme {}".format(
+                                    parse_result
+                                )
+                            )
+                    else:
+                        raise TypeError(
+                            "encryption is not supported for content type {}".format(
+                                type(part)
+                            )
+                        )
+            else:
+                raise TypeError(
+                    "encryption is not supported for content type {}".format(
+                        type(message.get("content"))
+                    )
+                )

volcenginesdkarkruntime/resources/images/images.py

@@ -21,10 +21,11 @@ from ..._types import NOT_GIVEN, NotGiven
 from ..._base_client import make_request_options
 from ..._utils._utils import apikey_required, async_apikey_required
 from ..._resource import SyncAPIResource, AsyncAPIResource
-from ...types.images import SequentialImageGenerationOptions, ImagesResponse
+from ...types.images import OptimizePromptOptions, SequentialImageGenerationOptions, ImagesResponse
 from ...types.images.image_gen_stream_event import ImageGenStreamEvent
 from ..._types import Body, Query, Headers
 from ..._streaming import Stream
+from ...types.images.images import OptimizePromptOptions
 
 
 class Images(SyncAPIResource):
@@ -41,6 +42,7 @@ class Images(SyncAPIResource):
         guidance_scale: float | None = None,
         watermark: bool | None = None,
         optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
@@ -72,6 +74,7 @@ class Images(SyncAPIResource):
         guidance_scale: float | None = None,
         watermark: bool | None = None,
         optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
@@ -95,6 +98,7 @@ class Images(SyncAPIResource):
         guidance_scale: float | None = None,
         watermark: bool | None = None,
         optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
@@ -118,6 +122,7 @@ class Images(SyncAPIResource):
         guidance_scale: float | None = None,
         watermark: bool | None = None,
         optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
@@ -138,6 +143,10 @@ class Images(SyncAPIResource):
                 "guidance_scale": guidance_scale,
                 "watermark": watermark,
                 "optimize_prompt": optimize_prompt,
+                "optimize_prompt_options": (
+                    optimize_prompt_options.model_dump(mode="json")
+                    if optimize_prompt_options is not None else None
+                ),
                 "sequential_image_generation": sequential_image_generation,
                 "sequential_image_generation_options": (
                     sequential_image_generation_options.model_dump(mode="json")
@@ -162,70 +171,73 @@ class Images(SyncAPIResource):
 class AsyncImages(AsyncAPIResource):
     @overload
     async def generate(
-            self,
-            *,
-            model: str,
-            prompt: str,
-            image: str | list[str] | None = None,
-            response_format: str | None = None,
-            size: str | None = None,
-            seed: int | None = None,
-            guidance_scale: float | None = None,
-            watermark: bool | None = None,
-            optimize_prompt: bool | None = None,
-            extra_headers: Headers | None = None,
-            extra_query: Query | None = None,
-            extra_body: Body | None = None,
-            timeout: float | httpx.Timeout | None = None,
-            sequential_image_generation: str | None = None,
-            sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
-            stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
+        self,
+        *,
+        model: str,
+        prompt: str,
+        image: str | list[str] | None = None,
+        response_format: str | None = None,
+        size: str | None = None,
+        seed: int | None = None,
+        guidance_scale: float | None = None,
+        watermark: bool | None = None,
+        optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
+        sequential_image_generation: str | None = None,
+        sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
+        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
     ) -> ImagesResponse:
         ...
 
     @overload
     async def generate(
-            self,
-            *,
-            model: str,
-            prompt: str,
-            image: str | list[str] | None = None,
-            response_format: str | None = None,
-            size: str | None = None,
-            seed: int | None = None,
-            guidance_scale: float | None = None,
-            watermark: bool | None = None,
-            optimize_prompt: bool | None = None,
-            extra_headers: Headers | None = None,
-            extra_query: Query | None = None,
-            extra_body: Body | None = None,
-            timeout: float | httpx.Timeout | None = None,
-            sequential_image_generation: str | None = None,
-            sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
-            stream: Literal[True],
+        self,
+        *,
+        model: str,
+        prompt: str,
+        image: str | list[str] | None = None,
+        response_format: str | None = None,
+        size: str | None = None,
+        seed: int | None = None,
+        guidance_scale: float | None = None,
+        watermark: bool | None = None,
+        optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
+        sequential_image_generation: str | None = None,
+        sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
+        stream: Literal[True],
     ) -> Stream[ImageGenStreamEvent]:
         ...
 
     @overload
     async def generate(
-            self,
-            *,
-            model: str,
-            prompt: str,
-            image: str | list[str] | None = None,
-            response_format: str | None = None,
-            size: str | None = None,
-            seed: int | None = None,
-            guidance_scale: float | None = None,
-            watermark: bool | None = None,
-            optimize_prompt: bool | None = None,
-            extra_headers: Headers | None = None,
-            extra_query: Query | None = None,
-            extra_body: Body | None = None,
-            timeout: float | httpx.Timeout | None = None,
-            sequential_image_generation: str | None = None,
-            sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
-            stream: bool,
+        self,
+        *,
+        model: str,
+        prompt: str,
+        image: str | list[str] | None = None,
+        response_format: str | None = None,
+        size: str | None = None,
+        seed: int | None = None,
+        guidance_scale: float | None = None,
+        watermark: bool | None = None,
+        optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
+        sequential_image_generation: str | None = None,
+        sequential_image_generation_options: SequentialImageGenerationOptions | None = None,
+        stream: bool,
     ) -> ImagesResponse | Stream[ImageGenStreamEvent]:
         ...
 
@@ -242,6 +254,7 @@ class AsyncImages(AsyncAPIResource):
         guidance_scale: float | None = None,
         watermark: bool | None = None,
         optimize_prompt: bool | None = None,
+        optimize_prompt_options: OptimizePromptOptions | None = None,
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
@@ -262,6 +275,10 @@ class AsyncImages(AsyncAPIResource):
                 "guidance_scale": guidance_scale,
                 "watermark": watermark,
                 "optimize_prompt": optimize_prompt,
+                "optimize_prompt_options": (
+                    optimize_prompt_options.model_dump(mode="json")
+                    if optimize_prompt_options is not None else None
+                ),
                 "sequential_image_generation": sequential_image_generation,
                 "sequential_image_generation_options": (
                     sequential_image_generation_options.model_dump(mode="json")

volcenginesdkarkruntime/resources/responses/responses.py

@@ -1,4 +1,3 @@
-
 # Copyright (c) [2025] [OpenAI]
 # Copyright (c) [2025] [ByteDance Ltd. and/or its affiliates.]
 # SPDX-License-Identifier: Apache-2.0
@@ -41,12 +40,15 @@ from ...types.responses.response_input_param import ResponseInputParam
 from ...types.responses.response_stream_event import ResponseStreamEvent
 from ...types.responses.response_text_config_param import ResponseTextConfigParam
 from ...types.responses.response_caching_param import ResponseCaching
+from ...types.shared_params import Reasoning
 from volcenginesdkarkruntime.types.shared_params.thinking import Thinking
 
 __all__ = ["Responses", "AsyncResponses"]
 
 
-def _add_beta_headers(extra_headers: Headers | None = None, tools: Iterable[ToolParam] | None = ()) -> Headers:
+def _add_beta_headers(
+    extra_headers: Headers | None = None, tools: Iterable[ToolParam] | None = ()
+) -> Headers:
     if tools is None:
         return extra_headers
     for tool_param in tools:
@@ -95,6 +97,7 @@ class Responses(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | None = None,
+        reasoning: Optional[Reasoning] | None = None,
     ) -> Response | Stream[ResponseStreamEvent]:
         extra_headers = _add_beta_headers(extra_headers, tools)
         resp = self._post(
@@ -117,6 +120,7 @@ class Responses(SyncAPIResource):
                 "top_p": top_p,
                 "max_tool_calls": max_tool_calls,
                 "expire_at": expire_at,
+                "reasoning": reasoning,
             },
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -134,14 +138,15 @@ class Responses(SyncAPIResource):
         self,
         response_id: str,
         *,
-
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None = None,
     ) -> Response:
         if not response_id:
-            raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
+            raise ValueError(
+                f"Expected a non-empty value for `response_id` but received {response_id!r}"
+            )
         return self._get(
             f"/responses/{response_id}",
             options=make_request_options(
@@ -165,12 +170,17 @@ class Responses(SyncAPIResource):
         timeout: float | httpx.Timeout | None = None,
     ) -> None:
         if not response_id:
-            raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
+            raise ValueError(
+                f"Expected a non-empty value for `response_id` but received {response_id!r}"
+            )
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._delete(
             f"/responses/{response_id}",
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
             ),
             cast_to=type(None),
         )
@@ -210,6 +220,7 @@ class AsyncResponses(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | None = None,
+        reasoning: Optional[Reasoning] | None = None,
     ) -> Response | AsyncStream[ResponseStreamEvent]:
         extra_headers = _add_beta_headers(extra_headers, tools)
         resp = await self._post(
@@ -232,6 +243,7 @@ class AsyncResponses(AsyncAPIResource):
                 "top_p": top_p,
                 "max_tool_calls": max_tool_calls,
                 "expire_at": expire_at,
+                "reasoning": reasoning,
             },
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -247,17 +259,18 @@ class AsyncResponses(AsyncAPIResource):
         return resp
 
     async def retrieve(
-            self,
-            response_id: str,
-            *,
-
-            extra_headers: Headers | None = None,
-            extra_query: Query | None = None,
-            extra_body: Body | None = None,
-            timeout: float | httpx.Timeout | None = None,
+        self,
+        response_id: str,
+        *,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
     ) -> Response:
         if not response_id:
-            raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
+            raise ValueError(
+                f"Expected a non-empty value for `response_id` but received {response_id!r}"
+            )
         return await self._get(
             f"/responses/{response_id}",
             options=make_request_options(
@@ -272,21 +285,26 @@ class AsyncResponses(AsyncAPIResource):
         )
 
     async def delete(
-            self,
-            response_id: str,
-            *,
-            extra_headers: Headers | None = None,
-            extra_query: Query | None = None,
-            extra_body: Body | None = None,
-            timeout: float | httpx.Timeout | None = None,
+        self,
+        response_id: str,
+        *,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
     ) -> None:
         if not response_id:
-            raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
+            raise ValueError(
+                f"Expected a non-empty value for `response_id` but received {response_id!r}"
+            )
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._delete(
             f"/responses/{response_id}",
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
             ),
             cast_to=type(None),
         )

volcenginesdkarkruntime/types/__init__.py

@@ -16,6 +16,8 @@ from .shared import (
     ResponseFormatText as ResponseFormatText,
     ResponseFormatJSONObject as ResponseFormatJSONObject,
     ResponseFormatJSONSchema as ResponseFormatJSONSchema,
+    Reasoning as Reasoning,
+    ReasoningEffort as ReasoningEffort,
 )
 from .embedding import Embedding as Embedding
 from .completion_usage import CompletionUsage as CompletionUsage

volcenginesdkarkruntime/types/content_generation/content_generation_task.py

@@ -27,6 +27,9 @@ class Content(BaseModel):
     last_frame_url: str
     """The URL of the last frame of the generated video, if any."""
 
+    file_url: str
+    """The URL of the generated file, if any."""
+
 
 class ContentGenerationError(BaseModel):
     message: str
@@ -55,6 +58,18 @@ class ContentGenerationTask(BaseModel):
     usage: Usage
     """The usage information for the task."""
 
+    subdivisionlevel: str
+    """The subdivision level of the task."""
+
+    fileformat: str
+    """The file format of the generated content."""
+
+    frames: int
+    """The number of frames in the generated content."""
+
+    framespersecond: int
+    """The number of frames per second in the generated content."""
+
     created_at: int
     """The Unix timestamp when the task was created."""
 

volcenginesdkarkruntime/types/images/__init__.py

@@ -10,7 +10,7 @@
 #
 # This modified file is released under the same license.
 
-from .images import SequentialImageGenerationOptions, ImagesResponse
+from .images import OptimizePromptOptions, SequentialImageGenerationOptions, ImagesResponse
 
 
-__all__ = ["SequentialImageGenerationOptions", "ImagesResponse"]
+__all__ = ["OptimizePromptOptions", "SequentialImageGenerationOptions", "ImagesResponse"]

volcenginesdkarkruntime/types/images/images.py

@@ -14,13 +14,19 @@ from typing import List, Optional
 
 from volcenginesdkarkruntime._models import BaseModel
 
-__all__ = ["SequentialImageGenerationOptions", "ImagesResponse"]
+__all__ = ["OptimizePromptOptions", "SequentialImageGenerationOptions", "ImagesResponse"]
+
+
+class OptimizePromptOptions(BaseModel):
+    thinking: Optional[str] = None
+    mode: Optional[str] = None
 
 
 class SequentialImageGenerationOptions(BaseModel):
     max_images: Optional[int] = None
     """ Maximum number of images to generate in this request; effective only when the multi-image feature is enabled """
 
+
 class Usage(BaseModel):
     generated_images: int
     """The number of images generated."""

volcenginesdkarkruntime/types/responses/audio_chunking_strategy.py

@@ -0,0 +1,30 @@
+# Copyright (c) [2025] [OpenAI]
+# Copyright (c) [2025] [ByteDance Ltd. and/or its affiliates.]
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file has been modified by [ByteDance Ltd. and/or its affiliates.] on 2025.7
+#
+# Original file was released under Apache License Version 2.0, with the full license text
+# available at https://github.com/openai/openai-python/blob/main/LICENSE.
+#
+# This modified file is released under the same license.
+
+from __future__ import annotations
+
+from typing import Optional
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["AudioChunkingStrategy"]
+
+
+class AudioChunkingStrategy(BaseModel):
+    type: Literal["server_vad"]
+
+    prefix_padding_ms: Optional[int] = None
+
+    silence_duration_ms: Optional[int] = None
+
+    threshold: Optional[float] = None