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

vapi/types/tool_message_complete.py

@@ -0,0 +1,74 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import pydantic
+from .tool_message_complete_role import ToolMessageCompleteRole
+import typing_extensions
+from ..core.serialization import FieldMetadata
+from .condition import Condition
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class ToolMessageComplete(UniversalBaseModel):
+    type: typing.Literal["request-complete"] = pydantic.Field(default="request-complete")
+    """
+    This message is triggered when the tool call is complete.
+    
+    This message is triggered immediately without waiting for your server to respond for async tool calls.
+    
+    If this message is not provided, the model will be requested to respond.
+    
+    If this message is provided, only this message will be spoken and the model will not be requested to come up with a response. It's an exclusive OR.
+    """
+
+    role: typing.Optional[ToolMessageCompleteRole] = pydantic.Field(default=None)
+    """
+    This is optional and defaults to "assistant".
+    
+    When role=assistant, `content` is said out loud.
+    
+    When role=system, `content` is passed to the model in a system message. Example:
+    system: default one
+    assistant:
+    user:
+    assistant:
+    user:
+    assistant:
+    user:
+    assistant: tool called
+    tool: your server response
+    <--- system prompt as hint
+    ---> model generates response which is spoken
+    This is useful when you want to provide a hint to the model about what to say next.
+    """
+
+    end_call_after_spoken_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="endCallAfterSpokenEnabled")
+    ] = pydantic.Field(default=None)
+    """
+    This is an optional boolean that if true, the call will end after the message is spoken. Default is false.
+    
+    This is ignored if `role` is set to `system`.
+    
+    @default false
+    """
+
+    content: str = pydantic.Field()
+    """
+    This is the content that the assistant says when this message is triggered.
+    """
+
+    conditions: typing.Optional[typing.List[Condition]] = pydantic.Field(default=None)
+    """
+    This is an optional array of conditions that the tool call arguments must meet in order for this message to be triggered.
+    """
+
+    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/tool_message_complete_role.py

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

vapi/types/tool_message_delayed.py

@@ -0,0 +1,49 @@
+# 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 .condition import Condition
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class ToolMessageDelayed(UniversalBaseModel):
+    type: typing.Literal["request-response-delayed"] = pydantic.Field(default="request-response-delayed")
+    """
+    This message is triggered when the tool call is delayed.
+    
+    There are the two things that can trigger this message:
+    
+    1. The user talks with the assistant while your server is processing the request. Default is "Sorry, a few more seconds."
+    2. The server doesn't respond within `timingMilliseconds`.
+    
+    This message is never triggered for async tool calls.
+    """
+
+    timing_milliseconds: typing_extensions.Annotated[
+        typing.Optional[float], FieldMetadata(alias="timingMilliseconds")
+    ] = pydantic.Field(default=None)
+    """
+    The number of milliseconds to wait for the server response before saying this message.
+    """
+
+    content: str = pydantic.Field()
+    """
+    This is the content that the assistant says when this message is triggered.
+    """
+
+    conditions: typing.Optional[typing.List[Condition]] = pydantic.Field(default=None)
+    """
+    This is an optional array of conditions that the tool call arguments must meet in order for this message to be triggered.
+    """
+
+    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/tool_message_failed.py

@@ -0,0 +1,50 @@
+# 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 .condition import Condition
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class ToolMessageFailed(UniversalBaseModel):
+    type: typing.Literal["request-failed"] = pydantic.Field(default="request-failed")
+    """
+    This message is triggered when the tool call fails.
+    
+    This message is never triggered for async tool calls.
+    
+    If this message is not provided, the model will be requested to respond.
+    
+    If this message is provided, only this message will be spoken and the model will not be requested to come up with a response. It's an exclusive OR.
+    """
+
+    end_call_after_spoken_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="endCallAfterSpokenEnabled")
+    ] = pydantic.Field(default=None)
+    """
+    This is an optional boolean that if true, the call will end after the message is spoken. Default is false.
+    
+    @default false
+    """
+
+    content: str = pydantic.Field()
+    """
+    This is the content that the assistant says when this message is triggered.
+    """
+
+    conditions: typing.Optional[typing.List[Condition]] = pydantic.Field(default=None)
+    """
+    This is an optional array of conditions that the tool call arguments must meet in order for this message to be triggered.
+    """
+
+    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/tool_message_start.py

@@ -0,0 +1,37 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import pydantic
+from .condition import Condition
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class ToolMessageStart(UniversalBaseModel):
+    type: typing.Literal["request-start"] = pydantic.Field(default="request-start")
+    """
+    This message is triggered when the tool call starts.
+    
+    This message is never triggered for async tools.
+    
+    If this message is not provided, one of the default filler messages "Hold on a sec", "One moment", "Just a sec", "Give me a moment" or "This'll just take a sec" will be used.
+    """
+
+    content: str = pydantic.Field()
+    """
+    This is the content that the assistant says when this message is triggered.
+    """
+
+    conditions: typing.Optional[typing.List[Condition]] = pydantic.Field(default=None)
+    """
+    This is an optional array of conditions that the tool call arguments must meet in order for this message to be triggered.
+    """
+
+    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/tool_template_metadata.py

@@ -0,0 +1,23 @@
+# 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
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class ToolTemplateMetadata(UniversalBaseModel):
+    collection_type: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="collectionType")] = None
+    collection_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="collectionId")] = None
+    collection_name: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="collectionName")] = None
+
+    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/tool_template_setup.py

@@ -0,0 +1,24 @@
+# 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
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class ToolTemplateSetup(UniversalBaseModel):
+    title: str
+    description: typing.Optional[str] = None
+    video_url: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="videoUrl")] = None
+    docs_url: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="docsUrl")] = None
+
+    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/transcriber_cost.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 pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class TranscriberCost(UniversalBaseModel):
+    type: typing.Literal["transcriber"] = pydantic.Field(default="transcriber")
+    """
+    This is the type of cost, always 'transcriber' for this class.
+    """
+
+    transcriber: typing.Dict[str, typing.Optional[typing.Any]] = pydantic.Field()
+    """
+    This is the transcriber that was used during the call.
+    
+    This matches one of the below:
+    
+    - `call.assistant.transcriber`,
+    - `call.assistantId->transcriber`,
+    - `call.squad[n].assistant.transcriber`,
+    - `call.squad[n].assistantId->transcriber`,
+    - `call.squadId->[n].assistant.transcriber`,
+    - `call.squadId->[n].assistantId->transcriber`.
+    """
+
+    minutes: float = pydantic.Field()
+    """
+    This is the minutes of `transcriber` usage. This should match `call.endedAt` - `call.startedAt` for single assistant calls, while squad calls will have multiple transcriber 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/transcript_plan.py

@@ -0,0 +1,66 @@
+# 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 TranscriptPlan(UniversalBaseModel):
+    enabled: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    This determines whether the transcript is stored in `call.artifact.transcript`. Defaults to true.
+    
+    @default true
+    """
+
+    assistant_name: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="assistantName")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the name of the assistant in the transcript. Defaults to 'AI'.
+    
+    Usage:
+    
+    - If you want to change the name of the assistant in the transcript, set this. Example, here is what the transcript would look like with `assistantName` set to 'Buyer':
+    
+    ```
+    User: Hello, how are you?
+    Buyer: I'm fine.
+    User: Do you want to buy a car?
+    Buyer: No.
+    ```
+    
+    @default 'AI'
+    """
+
+    user_name: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="userName")] = pydantic.Field(
+        default=None
+    )
+    """
+    This is the name of the user in the transcript. Defaults to 'User'.
+    
+    Usage:
+    
+    - If you want to change the name of the user in the transcript, set this. Example, here is what the transcript would look like with `userName` set to 'Seller':
+    
+    ```
+    Seller: Hello, how are you?
+    AI: I'm fine.
+    Seller: Do you want to buy a car?
+    AI: No.
+    ```
+    
+    @default 'User'
+    """
+
+    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/transcription_endpointing_plan.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 ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class TranscriptionEndpointingPlan(UniversalBaseModel):
+    on_punctuation_seconds: typing_extensions.Annotated[
+        typing.Optional[float], FieldMetadata(alias="onPunctuationSeconds")
+    ] = pydantic.Field(default=None)
+    """
+    The minimum number of seconds to wait after transcription ending with punctuation before sending a request to the model. Defaults to 0.1.
+    
+    This setting exists because the transcriber punctuates the transcription when it's more confident that customer has completed a thought.
+    
+    @default 0.1
+    """
+
+    on_no_punctuation_seconds: typing_extensions.Annotated[
+        typing.Optional[float], FieldMetadata(alias="onNoPunctuationSeconds")
+    ] = pydantic.Field(default=None)
+    """
+    The minimum number of seconds to wait after transcription ending without punctuation before sending a request to the model. Defaults to 1.5.
+    
+    This setting exists to catch the cases where the transcriber was not confident enough to punctuate the transcription, but the customer is done and has been silent for a long time.
+    
+    @default 1.5
+    """
+
+    on_number_seconds: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="onNumberSeconds")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    The minimum number of seconds to wait after transcription ending with a number before sending a request to the model. Defaults to 0.4.
+    
+    This setting exists because the transcriber will sometimes punctuate the transcription ending with a number, even though the customer hasn't uttered the full number. This happens commonly for long numbers when the customer reads the number in chunks.
+    
+    @default 0.5
+    """
+
+    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/transfer_call_tool.py

@@ -0,0 +1,88 @@
+# 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 .transfer_call_tool_messages_item import TransferCallToolMessagesItem
+from .transfer_call_tool_destinations_item import TransferCallToolDestinationsItem
+import datetime as dt
+from .open_ai_function import OpenAiFunction
+from .server import Server
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class TransferCallTool(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[TransferCallToolMessagesItem]] = 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["transferCall"] = "transferCall"
+    destinations: typing.Optional[typing.List[TransferCallToolDestinationsItem]] = pydantic.Field(default=None)
+    """
+    These are the destinations that the call can be transferred to. If no destinations are provided, server.url will be used to get the transfer destination once the tool is called.
+    """
+
+    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/transfer_call_tool_destinations_item.py

@@ -0,0 +1,11 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .transfer_destination_assistant import TransferDestinationAssistant
+from .transfer_destination_step import TransferDestinationStep
+from .transfer_destination_number import TransferDestinationNumber
+from .transfer_destination_sip import TransferDestinationSip
+
+TransferCallToolDestinationsItem = typing.Union[
+    TransferDestinationAssistant, TransferDestinationStep, TransferDestinationNumber, TransferDestinationSip
+]

vapi/types/transfer_call_tool_messages_item.py

@@ -0,0 +1,11 @@
+# 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
+
+TransferCallToolMessagesItem = typing.Union[
+    ToolMessageStart, ToolMessageComplete, ToolMessageFailed, ToolMessageDelayed
+]

vapi/types/transfer_destination_assistant.py

@@ -0,0 +1,90 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import typing_extensions
+from .transfer_mode import TransferMode
+from ..core.serialization import FieldMetadata
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class TransferDestinationAssistant(UniversalBaseModel):
+    type: typing.Literal["assistant"] = "assistant"
+    transfer_mode: typing_extensions.Annotated[typing.Optional[TransferMode], FieldMetadata(alias="transferMode")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the mode to use for the transfer. Default is `rolling-history`.
+    
+    - `rolling-history`: This is the default mode. It keeps the entire conversation history and appends the new assistant's system message on transfer.
+    
+      Example:
+    
+      Pre-transfer:
+      system: assistant1 system message
+      assistant: assistant1 first message
+      user: hey, good morning
+      assistant: how can i help?
+      user: i need help with my account
+      assistant: (destination.message)
+    
+      Post-transfer:
+      system: assistant1 system message
+      assistant: assistant1 first message
+      user: hey, good morning
+      assistant: how can i help?
+      user: i need help with my account
+      assistant: (destination.message)
+      system: assistant2 system message
+      assistant: assistant2 first message (or model generated if firstMessageMode is set to `assistant-speaks-first-with-model-generated-message`)
+    
+    - `swap-system-message-in-history`: This replaces the original system message with the new assistant's system message on transfer.
+    
+      Example:
+    
+      Pre-transfer:
+      system: assistant1 system message
+      assistant: assistant1 first message
+      user: hey, good morning
+      assistant: how can i help?
+      user: i need help with my account
+      assistant: (destination.message)
+    
+      Post-transfer:
+      system: assistant2 system message
+      assistant: assistant1 first message
+      user: hey, good morning
+      assistant: how can i help?
+      user: i need help with my account
+      assistant: (destination.message)
+      assistant: assistant2 first message (or model generated if firstMessageMode is set to `assistant-speaks-first-with-model-generated-message`)
+    """
+
+    assistant_name: typing_extensions.Annotated[str, FieldMetadata(alias="assistantName")] = pydantic.Field()
+    """
+    This is the assistant to transfer the call to.
+    """
+
+    message: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    This is the message to say before transferring the call to the destination.
+    
+    If this is not provided and transfer tool messages is not provided, default is "Transferring the call now".
+    
+    If set to "", nothing is spoken. This is useful when you want to silently transfer. This is especially useful when transferring between assistants in a squad. In this scenario, you likely also want to set `assistant.firstMessageMode=assistant-speaks-first-with-model-generated-message` for the destination assistant.
+    """
+
+    description: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    This is the description of the destination, used by the AI to choose when and how to transfer the call.
+    """
+
+    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