vapi-server-sdk 0.0.0a7__py3-none-any.whl

vapi/types/deep_infra_credential.py

@@ -0,0 +1,46 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import typing_extensions
+from ..core.serialization import FieldMetadata
+import pydantic
+import datetime as dt
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class DeepInfraCredential(UniversalBaseModel):
+    provider: typing.Literal["deepinfra"] = "deepinfra"
+    api_key: typing_extensions.Annotated[str, FieldMetadata(alias="apiKey")] = pydantic.Field()
+    """
+    This is not returned in the API.
+    """
+
+    id: str = pydantic.Field()
+    """
+    This is the unique identifier for the credential.
+    """
+
+    org_id: typing_extensions.Annotated[str, FieldMetadata(alias="orgId")] = pydantic.Field()
+    """
+    This is the unique identifier for the org that this credential belongs to.
+    """
+
+    created_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="createdAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the credential was created.
+    """
+
+    updated_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="updatedAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the assistant was last updated.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/deep_infra_model.py

@@ -0,0 +1,90 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .open_ai_message import OpenAiMessage
+import pydantic
+from .deep_infra_model_tools_item import DeepInfraModelToolsItem
+import typing_extensions
+from ..core.serialization import FieldMetadata
+from .knowledge_base import KnowledgeBase
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class DeepInfraModel(UniversalBaseModel):
+    messages: typing.Optional[typing.List[OpenAiMessage]] = pydantic.Field(default=None)
+    """
+    This is the starting state for the conversation.
+    """
+
+    tools: typing.Optional[typing.List[DeepInfraModelToolsItem]] = pydantic.Field(default=None)
+    """
+    These are the tools that the assistant can use during the call. To use existing tools, use `toolIds`.
+    
+    Both `tools` and `toolIds` can be used together.
+    """
+
+    tool_ids: typing_extensions.Annotated[typing.Optional[typing.List[str]], FieldMetadata(alias="toolIds")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    These are the tools that the assistant can use during the call. To use transient tools, use `tools`.
+    
+    Both `tools` and `toolIds` can be used together.
+    """
+
+    provider: typing.Literal["deepinfra"] = "deepinfra"
+    model: str = pydantic.Field()
+    """
+    This is the name of the model. Ex. cognitivecomputations/dolphin-mixtral-8x7b
+    """
+
+    temperature: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    This is the temperature that will be used for calls. Default is 0 to leverage caching for lower latency.
+    """
+
+    knowledge_base: typing_extensions.Annotated[
+        typing.Optional[KnowledgeBase], FieldMetadata(alias="knowledgeBase")
+    ] = pydantic.Field(default=None)
+    """
+    These are the options for the knowledge base.
+    """
+
+    max_tokens: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="maxTokens")] = pydantic.Field(
+        default=None
+    )
+    """
+    This is the max number of tokens that the assistant will be allowed to generate in each turn of the conversation. Default is 250.
+    """
+
+    emotion_recognition_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="emotionRecognitionEnabled")
+    ] = pydantic.Field(default=None)
+    """
+    This determines whether we detect user's emotion while they speak and send it as an additional info to model.
+    
+    Default `false` because the model is usually are good at understanding the user's emotion from text.
+    
+    @default false
+    """
+
+    num_fast_turns: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="numFastTurns")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This sets how many turns at the start of the conversation to use a smaller, faster model from the same provider before switching to the primary model. Example, gpt-3.5-turbo if provider is openai.
+    
+    Default is 0.
+    
+    @default 0
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/deep_infra_model_tools_item.py

@@ -0,0 +1,20 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .create_dtmf_tool_dto import CreateDtmfToolDto
+from .create_end_call_tool_dto import CreateEndCallToolDto
+from .create_voicemail_tool_dto import CreateVoicemailToolDto
+from .create_function_tool_dto import CreateFunctionToolDto
+from .create_ghl_tool_dto import CreateGhlToolDto
+from .create_make_tool_dto import CreateMakeToolDto
+from .create_transfer_call_tool_dto import CreateTransferCallToolDto
+
+DeepInfraModelToolsItem = typing.Union[
+    CreateDtmfToolDto,
+    CreateEndCallToolDto,
+    CreateVoicemailToolDto,
+    CreateFunctionToolDto,
+    CreateGhlToolDto,
+    CreateMakeToolDto,
+    CreateTransferCallToolDto,
+]

vapi/types/deepgram_credential.py

@@ -0,0 +1,53 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import typing_extensions
+from ..core.serialization import FieldMetadata
+import pydantic
+import datetime as dt
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class DeepgramCredential(UniversalBaseModel):
+    provider: typing.Literal["deepgram"] = "deepgram"
+    api_key: typing_extensions.Annotated[str, FieldMetadata(alias="apiKey")] = pydantic.Field()
+    """
+    This is not returned in the API.
+    """
+
+    id: str = pydantic.Field()
+    """
+    This is the unique identifier for the credential.
+    """
+
+    org_id: typing_extensions.Annotated[str, FieldMetadata(alias="orgId")] = pydantic.Field()
+    """
+    This is the unique identifier for the org that this credential belongs to.
+    """
+
+    created_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="createdAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the credential was created.
+    """
+
+    updated_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="updatedAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the assistant was last updated.
+    """
+
+    api_url: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="apiUrl")] = pydantic.Field(
+        default=None
+    )
+    """
+    This can be used to point to an onprem Deepgram instance. Defaults to api.deepgram.com.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/deepgram_transcriber.py

@@ -0,0 +1,68 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import pydantic
+from .deepgram_transcriber_model import DeepgramTranscriberModel
+from .deepgram_transcriber_language import DeepgramTranscriberLanguage
+import typing_extensions
+from ..core.serialization import FieldMetadata
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class DeepgramTranscriber(UniversalBaseModel):
+    provider: typing.Literal["deepgram"] = pydantic.Field(default="deepgram")
+    """
+    This is the transcription provider that will be used.
+    """
+
+    model: typing.Optional[DeepgramTranscriberModel] = pydantic.Field(default=None)
+    """
+    This is the Deepgram model that will be used. A list of models can be found here: https://developers.deepgram.com/docs/models-languages-overview
+    """
+
+    language: typing.Optional[DeepgramTranscriberLanguage] = pydantic.Field(default=None)
+    """
+    This is the language that will be set for the transcription. The list of languages Deepgram supports can be found here: https://developers.deepgram.com/docs/models-languages-overview
+    """
+
+    smart_format: typing_extensions.Annotated[typing.Optional[bool], FieldMetadata(alias="smartFormat")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This will be use smart format option provided by Deepgram. It's default disabled because it can sometimes format numbers as times but it's getting better.
+    """
+
+    language_detection_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="languageDetectionEnabled")
+    ] = pydantic.Field(default=None)
+    """
+    This enables or disables language detection. If true, swaps transcribers to detected language automatically. Defaults to false.
+    """
+
+    keywords: typing.Optional[typing.List[str]] = pydantic.Field(default=None)
+    """
+    These keywords are passed to the transcription model to help it pick up use-case specific words. Anything that may not be a common word, like your company name, should be added here.
+    """
+
+    endpointing: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    This is the timeout after which Deepgram will send transcription on user silence. You can read in-depth documentation here: https://developers.deepgram.com/docs/endpointing.
+    
+    Here are the most important bits:
+    
+    - Defaults to 10. This is recommended for most use cases to optimize for latency.
+    - 10 can cause some missing transcriptions since because of the shorter context. This mostly happens for one-word utterances. For those uses cases, it's recommended to try 300. It will add a bit of latency but the quality and reliability of the experience will be better.
+    - If neither 10 nor 300 work, contact support@vapi.ai and we'll find another solution.
+    
+    @default 10
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/deepgram_transcriber_language.py

@@ -0,0 +1,65 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+DeepgramTranscriberLanguage = typing.Union[
+    typing.Literal[
+        "bg",
+        "ca",
+        "cs",
+        "da",
+        "da-DK",
+        "de",
+        "de-CH",
+        "el",
+        "en",
+        "en-AU",
+        "en-GB",
+        "en-IN",
+        "en-NZ",
+        "en-US",
+        "es",
+        "es-419",
+        "es-LATAM",
+        "et",
+        "fi",
+        "fr",
+        "fr-CA",
+        "hi",
+        "hi-Latn",
+        "hu",
+        "id",
+        "it",
+        "ja",
+        "ko",
+        "ko-KR",
+        "lt",
+        "lv",
+        "ms",
+        "multi",
+        "nl",
+        "nl-BE",
+        "no",
+        "pl",
+        "pt",
+        "pt-BR",
+        "ro",
+        "ru",
+        "sk",
+        "sv",
+        "sv-SE",
+        "ta",
+        "taq",
+        "th",
+        "th-TH",
+        "tr",
+        "uk",
+        "vi",
+        "zh",
+        "zh-CN",
+        "zh-Hans",
+        "zh-Hant",
+        "zh-TW",
+    ],
+    typing.Any,
+]

vapi/types/deepgram_transcriber_model.py

@@ -0,0 +1,37 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+DeepgramTranscriberModel = typing.Union[
+    typing.Literal[
+        "nova-2",
+        "nova-2-general",
+        "nova-2-meeting",
+        "nova-2-phonecall",
+        "nova-2-finance",
+        "nova-2-conversationalai",
+        "nova-2-voicemail",
+        "nova-2-video",
+        "nova-2-medical",
+        "nova-2-drivethru",
+        "nova-2-automotive",
+        "nova",
+        "nova-general",
+        "nova-phonecall",
+        "nova-medical",
+        "enhanced",
+        "enhanced-general",
+        "enhanced-meeting",
+        "enhanced-phonecall",
+        "enhanced-finance",
+        "base",
+        "base-general",
+        "base-meeting",
+        "base-phonecall",
+        "base-finance",
+        "base-conversationalai",
+        "base-voicemail",
+        "base-video",
+    ],
+    typing.Any,
+]

vapi/types/deepgram_voice.py

@@ -0,0 +1,47 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import typing
+from ..core.serialization import FieldMetadata
+import pydantic
+from .deepgram_voice_id import DeepgramVoiceId
+from .chunk_plan import ChunkPlan
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class DeepgramVoice(UniversalBaseModel):
+    filler_injection_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="fillerInjectionEnabled")
+    ] = pydantic.Field(default=None)
+    """
+    This determines whether fillers are injected into the model output before inputting it into the voice provider.
+    
+    Default `false` because you can achieve better results with prompting the model.
+    """
+
+    provider: typing.Literal["deepgram"] = pydantic.Field(default="deepgram")
+    """
+    This is the voice provider that will be used.
+    """
+
+    voice_id: typing_extensions.Annotated[DeepgramVoiceId, FieldMetadata(alias="voiceId")] = pydantic.Field()
+    """
+    This is the provider-specific ID that will be used.
+    """
+
+    chunk_plan: typing_extensions.Annotated[typing.Optional[ChunkPlan], FieldMetadata(alias="chunkPlan")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the plan for chunking the model output before it is sent to the voice provider.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/deepgram_voice_id.py

@@ -0,0 +1,6 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .deepgram_voice_id_enum import DeepgramVoiceIdEnum
+
+DeepgramVoiceId = typing.Union[DeepgramVoiceIdEnum, str]

vapi/types/deepgram_voice_id_enum.py

@@ -0,0 +1,10 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+DeepgramVoiceIdEnum = typing.Union[
+    typing.Literal[
+        "asteria", "luna", "stella", "athena", "hera", "orion", "arcas", "perseus", "angus", "orpheus", "helios", "zeus"
+    ],
+    typing.Any,
+]

vapi/types/dtmf_tool.py

@@ -0,0 +1,82 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import typing
+from ..core.serialization import FieldMetadata
+import pydantic
+from .dtmf_tool_messages_item import DtmfToolMessagesItem
+import datetime as dt
+from .open_ai_function import OpenAiFunction
+from .server import Server
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class DtmfTool(UniversalBaseModel):
+    async_: typing_extensions.Annotated[typing.Optional[bool], FieldMetadata(alias="async")] = pydantic.Field(
+        default=None
+    )
+    """
+    This determines if the tool is async.
+    
+    If async, the assistant will move forward without waiting for your server to respond. This is useful if you just want to trigger something on your server.
+    
+    If sync, the assistant will wait for your server to respond. This is useful if want assistant to respond with the result from your server.
+    
+    Defaults to synchronous (`false`).
+    """
+
+    messages: typing.Optional[typing.List[DtmfToolMessagesItem]] = pydantic.Field(default=None)
+    """
+    These are the messages that will be spoken to the user as the tool is running.
+    
+    For some tools, this is auto-filled based on special fields like `tool.destinations`. For others like the function tool, these can be custom configured.
+    """
+
+    type: typing.Literal["dtmf"] = "dtmf"
+    id: str = pydantic.Field()
+    """
+    This is the unique identifier for the tool.
+    """
+
+    org_id: typing_extensions.Annotated[str, FieldMetadata(alias="orgId")] = pydantic.Field()
+    """
+    This is the unique identifier for the organization that this tool belongs to.
+    """
+
+    created_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="createdAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the tool was created.
+    """
+
+    updated_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="updatedAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the tool was last updated.
+    """
+
+    function: typing.Optional[OpenAiFunction] = pydantic.Field(default=None)
+    """
+    This is the function definition of the tool.
+    
+    For `endCall`, `transferCall`, and `dtmf` tools, this is auto-filled based on tool-specific fields like `tool.destinations`. But, even in those cases, you can provide a custom function definition for advanced use cases.
+    
+    An example of an advanced use case is if you want to customize the message that's spoken for `endCall` tool. You can specify a function where it returns an argument "reason". Then, in `messages` array, you can have many "request-complete" messages. One of these messages will be triggered if the `messages[].conditions` matches the "reason" argument.
+    """
+
+    server: typing.Optional[Server] = pydantic.Field(default=None)
+    """
+    This is the server that will be hit when this tool is requested by the model.
+    
+    All requests will be sent with the call object among other things. You can find more details in the Server URL documentation.
+    
+    This overrides the serverUrl set on the org and the phoneNumber. Order of precedence: highest tool.server.url, then assistant.serverUrl, then phoneNumber.serverUrl, then org.serverUrl.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/dtmf_tool_messages_item.py

@@ -0,0 +1,9 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .tool_message_start import ToolMessageStart
+from .tool_message_complete import ToolMessageComplete
+from .tool_message_failed import ToolMessageFailed
+from .tool_message_delayed import ToolMessageDelayed
+
+DtmfToolMessagesItem = typing.Union[ToolMessageStart, ToolMessageComplete, ToolMessageFailed, ToolMessageDelayed]

vapi/types/eleven_labs_credential.py

@@ -0,0 +1,46 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import typing_extensions
+from ..core.serialization import FieldMetadata
+import pydantic
+import datetime as dt
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class ElevenLabsCredential(UniversalBaseModel):
+    provider: typing.Literal["11labs"] = "11labs"
+    api_key: typing_extensions.Annotated[str, FieldMetadata(alias="apiKey")] = pydantic.Field()
+    """
+    This is not returned in the API.
+    """
+
+    id: str = pydantic.Field()
+    """
+    This is the unique identifier for the credential.
+    """
+
+    org_id: typing_extensions.Annotated[str, FieldMetadata(alias="orgId")] = pydantic.Field()
+    """
+    This is the unique identifier for the org that this credential belongs to.
+    """
+
+    created_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="createdAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the credential was created.
+    """
+
+    updated_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="updatedAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the assistant was last updated.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow