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

vapi/types/model_based_condition.py

@@ -0,0 +1,54 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class ModelBasedCondition(UniversalBaseModel):
+    type: typing.Literal["model-based"] = pydantic.Field(default="model-based")
+    """
+    This condition is based on a model.
+    """
+
+    instruction: str = pydantic.Field()
+    """
+    This is the instruction which should output a boolean value when passed to a model.
+    
+    You can reference any variable in the context of the current block execution (step):
+    
+    - "{{output.your-property-name}}" for current step's output
+    - "{{input.your-property-name}}" for current step's input
+    - "{{your-step-name.output.your-property-name}}" for another step's output (in the same workflow; read caveat #1)
+    - "{{your-step-name.input.your-property-name}}" for another step's input (in the same workflow; read caveat #1)
+    - "{{your-block-name.output.your-property-name}}" for another block's output (in the same workflow; read caveat #2)
+    - "{{your-block-name.input.your-property-name}}" for another block's input (in the same workflow; read caveat #2)
+    - "{{workflow.input.your-property-name}}" for the current workflow's input
+    - "{{global.your-property-name}}" for the global context
+    
+    You can also talk about the current step's output or input directly:
+    
+    - "{{output.your-property-name}} is greater than 10"
+    - "{{input.your-property-name}} is greater than 10"
+    
+    Examples:
+    
+    - "{{input.age}} is greater than 10"
+    - "{{input.age}} is greater than {{input.age2}}"
+    - "{{output.age}} is greater than 10"
+    
+    Caveats:
+    
+    1. a workflow can execute a step multiple times. example, if a loop is used in the graph. {{stepName.input/output.propertyName}} will reference the latest usage of the step.
+    2. a workflow can execute a block multiple times. example, if a step is called multiple times or if a block is used in multiple steps. {{blockName.input/output.propertyName}} will reference the latest usage of the block. this liquid variable is just provided for convenience when creating blocks outside of a workflow with steps.
+    """
+
+    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/model_cost.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 pydantic
+import typing_extensions
+from ..core.serialization import FieldMetadata
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class ModelCost(UniversalBaseModel):
+    type: typing.Literal["model"] = pydantic.Field(default="model")
+    """
+    This is the type of cost, always 'model' for this class.
+    """
+
+    model: typing.Dict[str, typing.Optional[typing.Any]] = pydantic.Field()
+    """
+    This is the model that was used during the call.
+    
+    This matches one of the following:
+    
+    - `call.assistant.model`,
+    - `call.assistantId->model`,
+    - `call.squad[n].assistant.model`,
+    - `call.squad[n].assistantId->model`,
+    - `call.squadId->[n].assistant.model`,
+    - `call.squadId->[n].assistantId->model`.
+    """
+
+    prompt_tokens: typing_extensions.Annotated[float, FieldMetadata(alias="promptTokens")] = pydantic.Field()
+    """
+    This is the number of prompt tokens used in the call. These should be total prompt tokens used in the call for single assistant calls, while squad calls will have multiple model costs one for each assistant that was used.
+    """
+
+    completion_tokens: typing_extensions.Annotated[float, FieldMetadata(alias="completionTokens")] = pydantic.Field()
+    """
+    This is the number of completion tokens generated in the call. These should be total completion tokens used in the call for single assistant calls, while squad calls will have multiple model costs one for each assistant that was used.
+    """
+
+    cost: float = pydantic.Field()
+    """
+    This is the cost of the component in USD.
+    """
+
+    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/monitor.py

@@ -0,0 +1,33 @@
+# 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 ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class Monitor(UniversalBaseModel):
+    listen_url: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="listenUrl")] = pydantic.Field(
+        default=None
+    )
+    """
+    This is the URL where the assistant's calls can be listened to in real-time. To enable, set `assistant.monitorPlan.listenEnabled` to `true`.
+    """
+
+    control_url: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="controlUrl")] = pydantic.Field(
+        default=None
+    )
+    """
+    This is the URL where the assistant's calls can be controlled in real-time. To enable, set `assistant.monitorPlan.controlEnabled` to `true`.
+    """
+
+    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/monitor_plan.py

@@ -0,0 +1,43 @@
+# 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 ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class MonitorPlan(UniversalBaseModel):
+    listen_enabled: typing_extensions.Annotated[typing.Optional[bool], FieldMetadata(alias="listenEnabled")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This determines whether the assistant's calls allow live listening. Defaults to true.
+    
+    Fetch `call.monitor.listenUrl` to get the live listening URL.
+    
+    @default true
+    """
+
+    control_enabled: typing_extensions.Annotated[typing.Optional[bool], FieldMetadata(alias="controlEnabled")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This determines whether the assistant's calls allow live control. Defaults to true.
+    
+    Fetch `call.monitor.controlUrl` to get the live control URL.
+    
+    To use, send any control message via a POST request to `call.monitor.controlUrl`. Here are the types of controls supported: https://docs.vapi.ai/api-reference/messages/client-inbound-message
+    
+    @default true
+    """
+
+    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/neets_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 .neets_voice_id import NeetsVoiceId
+from .chunk_plan import ChunkPlan
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class NeetsVoice(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["neets"] = pydantic.Field(default="neets")
+    """
+    This is the voice provider that will be used.
+    """
+
+    voice_id: typing_extensions.Annotated[NeetsVoiceId, 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/neets_voice_id.py

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

vapi/types/neets_voice_id_enum.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+NeetsVoiceIdEnum = typing.Union[typing.Literal["vits"], typing.Any]

vapi/types/open_ai_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 OpenAiCredential(UniversalBaseModel):
+    provider: typing.Literal["openai"] = "openai"
+    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/open_ai_function.py

@@ -0,0 +1,35 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import pydantic
+import typing
+from .open_ai_function_parameters import OpenAiFunctionParameters
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class OpenAiFunction(UniversalBaseModel):
+    name: str = pydantic.Field()
+    """
+    This is the the name of the function to be called.
+    
+    Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
+    """
+
+    description: typing.Optional[str] = None
+    parameters: typing.Optional[OpenAiFunctionParameters] = pydantic.Field(default=None)
+    """
+    These are the parameters the functions accepts, described as a JSON Schema object.
+    
+    See the [OpenAI guide](https://platform.openai.com/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema) for documentation about the format.
+    
+    Omitting parameters defines a function with an empty parameter list.
+    """
+
+    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/open_ai_function_parameters.py

@@ -0,0 +1,35 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import pydantic
+from .json_schema import JsonSchema
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class OpenAiFunctionParameters(UniversalBaseModel):
+    type: typing.Literal["object"] = pydantic.Field(default="object")
+    """
+    This must be set to 'object'. It instructs the model to return a JSON object containing the function call properties.
+    """
+
+    properties: typing.Dict[str, JsonSchema] = pydantic.Field()
+    """
+    This provides a description of the properties required by the function.
+    JSON Schema can be used to specify expectations for each property.
+    Refer to [this doc](https://ajv.js.org/json-schema.html#json-data-type) for a comprehensive guide on JSON Schema.
+    """
+
+    required: typing.Optional[typing.List[str]] = pydantic.Field(default=None)
+    """
+    This specifies the properties that are required by the function.
+    """
+
+    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/open_ai_message.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .open_ai_message_role import OpenAiMessageRole
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class OpenAiMessage(UniversalBaseModel):
+    content: typing.Optional[str] = None
+    role: OpenAiMessageRole
+
+    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/open_ai_message_role.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+OpenAiMessageRole = typing.Union[typing.Literal["assistant", "function", "user", "system", "tool"], typing.Any]

vapi/types/open_ai_model.py

@@ -0,0 +1,106 @@
+# 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 .open_ai_model_tools_item import OpenAiModelToolsItem
+import typing_extensions
+from ..core.serialization import FieldMetadata
+from .open_ai_model_model import OpenAiModelModel
+from .open_ai_model_fallback_models_item import OpenAiModelFallbackModelsItem
+from .knowledge_base import KnowledgeBase
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class OpenAiModel(UniversalBaseModel):
+    messages: typing.Optional[typing.List[OpenAiMessage]] = pydantic.Field(default=None)
+    """
+    This is the starting state for the conversation.
+    """
+
+    tools: typing.Optional[typing.List[OpenAiModelToolsItem]] = 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["openai"] = pydantic.Field(default="openai")
+    """
+    This is the provider that will be used for the model.
+    """
+
+    model: OpenAiModelModel = pydantic.Field()
+    """
+    This is the OpenAI model that will be used.
+    """
+
+    fallback_models: typing_extensions.Annotated[
+        typing.Optional[typing.List[OpenAiModelFallbackModelsItem]], FieldMetadata(alias="fallbackModels")
+    ] = pydantic.Field(default=None)
+    """
+    These are the fallback models that will be used if the primary model fails. This shouldn't be specified unless you have a specific reason to do so. Vapi will automatically find the fastest fallbacks that make sense.
+    """
+
+    semantic_caching_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="semanticCachingEnabled")
+    ] = None
+    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/open_ai_model_fallback_models_item.py

@@ -0,0 +1,26 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+OpenAiModelFallbackModelsItem = typing.Union[
+    typing.Literal[
+        "gpt-4o-mini",
+        "gpt-4o-mini-2024-07-18",
+        "gpt-4o",
+        "gpt-4o-2024-05-13",
+        "gpt-4o-2024-08-06",
+        "gpt-4-turbo",
+        "gpt-4-turbo-2024-04-09",
+        "gpt-4-turbo-preview",
+        "gpt-4-0125-preview",
+        "gpt-4-1106-preview",
+        "gpt-4",
+        "gpt-4-0613",
+        "gpt-3.5-turbo",
+        "gpt-3.5-turbo-0125",
+        "gpt-3.5-turbo-1106",
+        "gpt-3.5-turbo-16k",
+        "gpt-3.5-turbo-0613",
+    ],
+    typing.Any,
+]

vapi/types/open_ai_model_model.py

@@ -0,0 +1,26 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+OpenAiModelModel = typing.Union[
+    typing.Literal[
+        "gpt-4o-mini",
+        "gpt-4o-mini-2024-07-18",
+        "gpt-4o",
+        "gpt-4o-2024-05-13",
+        "gpt-4o-2024-08-06",
+        "gpt-4-turbo",
+        "gpt-4-turbo-2024-04-09",
+        "gpt-4-turbo-preview",
+        "gpt-4-0125-preview",
+        "gpt-4-1106-preview",
+        "gpt-4",
+        "gpt-4-0613",
+        "gpt-3.5-turbo",
+        "gpt-3.5-turbo-0125",
+        "gpt-3.5-turbo-1106",
+        "gpt-3.5-turbo-16k",
+        "gpt-3.5-turbo-0613",
+    ],
+    typing.Any,
+]

vapi/types/open_ai_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
+
+OpenAiModelToolsItem = typing.Union[
+    CreateDtmfToolDto,
+    CreateEndCallToolDto,
+    CreateVoicemailToolDto,
+    CreateFunctionToolDto,
+    CreateGhlToolDto,
+    CreateMakeToolDto,
+    CreateTransferCallToolDto,
+]

vapi/types/open_ai_voice.py

@@ -0,0 +1,52 @@
+# 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 .open_ai_voice_id import OpenAiVoiceId
+from .chunk_plan import ChunkPlan
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class OpenAiVoice(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["openai"] = pydantic.Field(default="openai")
+    """
+    This is the voice provider that will be used.
+    """
+
+    voice_id: typing_extensions.Annotated[OpenAiVoiceId, FieldMetadata(alias="voiceId")] = pydantic.Field()
+    """
+    This is the provider-specific ID that will be used.
+    """
+
+    speed: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    This is the speed multiplier 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/open_ai_voice_id.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+OpenAiVoiceId = typing.Union[typing.Literal["alloy", "echo", "fable", "onyx", "nova", "shimmer"], typing.Any]