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

vapi/types/anyscale_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 .anyscale_model_tools_item import AnyscaleModelToolsItem
+import typing_extensions
+from ..core.serialization import FieldMetadata
+from .knowledge_base import KnowledgeBase
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class AnyscaleModel(UniversalBaseModel):
+    messages: typing.Optional[typing.List[OpenAiMessage]] = pydantic.Field(default=None)
+    """
+    This is the starting state for the conversation.
+    """
+
+    tools: typing.Optional[typing.List[AnyscaleModelToolsItem]] = 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["anyscale"] = "anyscale"
+    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/anyscale_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
+
+AnyscaleModelToolsItem = typing.Union[
+    CreateDtmfToolDto,
+    CreateEndCallToolDto,
+    CreateVoicemailToolDto,
+    CreateFunctionToolDto,
+    CreateGhlToolDto,
+    CreateMakeToolDto,
+    CreateTransferCallToolDto,
+]

vapi/types/artifact.py

@@ -0,0 +1,66 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .artifact_messages_item import ArtifactMessagesItem
+import pydantic
+import typing_extensions
+from .open_ai_message import OpenAiMessage
+from ..core.serialization import FieldMetadata
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class Artifact(UniversalBaseModel):
+    messages: typing.Optional[typing.List[ArtifactMessagesItem]] = pydantic.Field(default=None)
+    """
+    These are the messages that were spoken during the call.
+    """
+
+    messages_open_ai_formatted: typing_extensions.Annotated[
+        typing.Optional[typing.List[OpenAiMessage]], FieldMetadata(alias="messagesOpenAIFormatted")
+    ] = pydantic.Field(default=None)
+    """
+    These are the messages that were spoken during the call, formatted for OpenAI.
+    """
+
+    recording_url: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="recordingUrl")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the recording url for the call. To enable, set `assistant.artifactPlan.recordingEnabled`.
+    """
+
+    stereo_recording_url: typing_extensions.Annotated[
+        typing.Optional[str], FieldMetadata(alias="stereoRecordingUrl")
+    ] = pydantic.Field(default=None)
+    """
+    This is the stereo recording url for the call. To enable, set `assistant.artifactPlan.recordingEnabled`.
+    """
+
+    video_recording_url: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="videoRecordingUrl")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is video recording url for the call. To enable, set `assistant.artifactPlan.videoRecordingEnabled`.
+    """
+
+    video_recording_start_delay_seconds: typing_extensions.Annotated[
+        typing.Optional[float], FieldMetadata(alias="videoRecordingStartDelaySeconds")
+    ] = pydantic.Field(default=None)
+    """
+    This is video recording start delay in ms. To enable, set `assistant.artifactPlan.videoRecordingEnabled`. This can be used to align the playback of the recording with artifact.messages timestamps.
+    """
+
+    transcript: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    This is the transcript of the call. This is derived from `artifact.messages` but provided for convenience.
+    """
+
+    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/artifact_messages_item.py

@@ -0,0 +1,10 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .user_message import UserMessage
+from .system_message import SystemMessage
+from .bot_message import BotMessage
+from .tool_call_message import ToolCallMessage
+from .tool_call_result_message import ToolCallResultMessage
+
+ArtifactMessagesItem = typing.Union[UserMessage, SystemMessage, BotMessage, ToolCallMessage, ToolCallResultMessage]

vapi/types/artifact_plan.py

@@ -0,0 +1,70 @@
+# 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 .transcript_plan import TranscriptPlan
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class ArtifactPlan(UniversalBaseModel):
+    recording_enabled: typing_extensions.Annotated[typing.Optional[bool], FieldMetadata(alias="recordingEnabled")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This determines whether assistant's calls are recorded. Defaults to true.
+    
+    Usage:
+    
+    - If you don't want to record the calls, set this to false.
+    - If you want to record the calls when `assistant.hipaaEnabled`, explicity set this to true and make sure to provide S3 or GCP credentials on the Provider Credentials page in the Dashboard.
+    
+    You can find the recording at `call.artifact.recordingUrl` and `call.artifact.stereoRecordingUrl` after the call is ended.
+    
+    @default true
+    """
+
+    video_recording_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="videoRecordingEnabled")
+    ] = pydantic.Field(default=None)
+    """
+    This determines whether the video is recorded during the call. Defaults to false. Only relevant for `webCall` type.
+    
+    You can find the video recording at `call.artifact.videoRecordingUrl` after the call is ended.
+    
+    @default false
+    """
+
+    transcript_plan: typing_extensions.Annotated[
+        typing.Optional[TranscriptPlan], FieldMetadata(alias="transcriptPlan")
+    ] = pydantic.Field(default=None)
+    """
+    This is the plan for `call.artifact.transcript`. To disable, set `transcriptPlan.enabled` to false.
+    """
+
+    recording_path: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="recordingPath")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the path where the recording will be uploaded. This is only used if you have provided S3 or GCP credentials on the Provider Credentials page in the Dashboard.
+    
+    If credential.s3PathPrefix or credential.bucketPlan.path is set, this will append to it.
+    
+    Usage:
+    
+    - If you want to upload the recording to a specific path, set this to the path. Example: `/my-assistant-recordings`.
+    - If you want to upload the recording to the root of the bucket, set this to `/`.
+    
+    @default '/'
+    """
+
+    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/assignment_mutation.py

@@ -0,0 +1,85 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .assignment_mutation_conditions_item import AssignmentMutationConditionsItem
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class AssignmentMutation(UniversalBaseModel):
+    conditions: typing.Optional[typing.List[AssignmentMutationConditionsItem]] = pydantic.Field(default=None)
+    """
+    This is an optional array of conditions that must be met for this mutation to be triggered.
+    """
+
+    type: typing.Literal["assignment"] = pydantic.Field(default="assignment")
+    """
+    This mutation assigns a new value to an existing or new variable.
+    """
+
+    variable: str = pydantic.Field()
+    """
+    This is the variable to assign a new value to.
+    
+    You can reference any variable in the context of the current block execution (step):
+    
+    - "output.your-property-name" for current step's output
+    - "your-step-name.output.your-property-name" for another step's output (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)
+    - "global.your-property-name" for the global context
+    
+    This needs to be the key path of the variable. If you use {{}}, it'll dereference that to the value of the variable before assignment. This can be useful if the path is dynamic. Example:
+    
+    - "global.{{my-tool-call-step.output.my-key-name}}"
+    
+    You can also string interpolate multiple variables to get the key name:
+    
+    - "global.{{my-tool-call-step.output.my-key-name-suffix}}-{{my-tool-call-step.output.my-key-name}}"
+    
+    The path to the new variable is created if it doesn't exist. Example:
+    
+    - "global.this-does-not-exist.neither-does-this" will create `this-does-not-exist` object with `neither-does-this` as a key
+    
+    Caveats:
+    
+    1. a workflow can execute a step multiple times. example, if a loop is used in the graph. {{stepName.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.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.
+    """
+
+    value: str = pydantic.Field()
+    """
+    The value to assign to the variable.
+    
+    You can reference any variable in the context of the current block execution (step):
+    
+    - "{{output.your-property-name}}" for current step's output
+    - "{{your-step-name.output.your-property-name}}" for another step's output (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)
+    - "{{global.your-property-name}}" for the global context
+    
+    Or, you can use a constant:
+    
+    - "1"
+    - "text"
+    - "true"
+    - "false"
+    
+    Or, you can mix and match with string interpolation:
+    
+    - "{{your-property-name}}-{{input.your-property-name-2}}-1"
+    
+    Caveats:
+    
+    1. a workflow can execute a step multiple times. example, if a loop is used in the graph. {{stepName.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.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.
+    """
+
+    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/assignment_mutation_conditions_item.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .model_based_condition import ModelBasedCondition
+from .rule_based_condition import RuleBasedCondition
+
+AssignmentMutationConditionsItem = typing.Union[ModelBasedCondition, RuleBasedCondition]

vapi/types/assistant.py

@@ -0,0 +1,330 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from __future__ import annotations
+from ..core.pydantic_utilities import UniversalBaseModel
+from .callback_step import CallbackStep
+from .create_workflow_block_dto import CreateWorkflowBlockDto
+from .handoff_step import HandoffStep
+import typing
+from .assistant_transcriber import AssistantTranscriber
+import pydantic
+from .assistant_model import AssistantModel
+from .assistant_voice import AssistantVoice
+import typing_extensions
+from .assistant_first_message_mode import AssistantFirstMessageMode
+from ..core.serialization import FieldMetadata
+from .assistant_client_messages_item import AssistantClientMessagesItem
+from .assistant_server_messages_item import AssistantServerMessagesItem
+from .assistant_background_sound import AssistantBackgroundSound
+from .transport_configuration_twilio import TransportConfigurationTwilio
+from .twilio_voicemail_detection import TwilioVoicemailDetection
+from .analysis_plan import AnalysisPlan
+from .artifact_plan import ArtifactPlan
+from .message_plan import MessagePlan
+from .start_speaking_plan import StartSpeakingPlan
+from .stop_speaking_plan import StopSpeakingPlan
+from .monitor_plan import MonitorPlan
+import datetime as dt
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from ..core.pydantic_utilities import update_forward_refs
+
+
+class Assistant(UniversalBaseModel):
+    transcriber: typing.Optional[AssistantTranscriber] = pydantic.Field(default=None)
+    """
+    These are the options for the assistant's transcriber.
+    """
+
+    model: typing.Optional[AssistantModel] = pydantic.Field(default=None)
+    """
+    These are the options for the assistant's LLM.
+    """
+
+    voice: typing.Optional[AssistantVoice] = pydantic.Field(default=None)
+    """
+    These are the options for the assistant's voice.
+    """
+
+    first_message_mode: typing_extensions.Annotated[
+        typing.Optional[AssistantFirstMessageMode], FieldMetadata(alias="firstMessageMode")
+    ] = pydantic.Field(default=None)
+    """
+    This is the mode for the first message. Default is 'assistant-speaks-first'.
+    
+    Use:
+    
+    - 'assistant-speaks-first' to have the assistant speak first.
+    - 'assistant-waits-for-user' to have the assistant wait for the user to speak first.
+    - 'assistant-speaks-first-with-model-generated-message' to have the assistant speak first with a message generated by the model based on the conversation state. (`assistant.model.messages` at call start, `call.messages` at squad transfer points).
+    
+    @default 'assistant-speaks-first'
+    """
+
+    hipaa_enabled: typing_extensions.Annotated[typing.Optional[bool], FieldMetadata(alias="hipaaEnabled")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    When this is enabled, no logs, recordings, or transcriptions will be stored. At the end of the call, you will still receive an end-of-call-report message to store on your server. Defaults to false.
+    """
+
+    client_messages: typing_extensions.Annotated[
+        typing.Optional[typing.List[AssistantClientMessagesItem]], FieldMetadata(alias="clientMessages")
+    ] = pydantic.Field(default=None)
+    """
+    These are the messages that will be sent to your Client SDKs. Default is conversation-update,function-call,hang,model-output,speech-update,status-update,transcript,tool-calls,user-interrupted,voice-input. You can check the shape of the messages in ClientMessage schema.
+    """
+
+    server_messages: typing_extensions.Annotated[
+        typing.Optional[typing.List[AssistantServerMessagesItem]], FieldMetadata(alias="serverMessages")
+    ] = pydantic.Field(default=None)
+    """
+    These are the messages that will be sent to your Server URL. Default is conversation-update,end-of-call-report,function-call,hang,speech-update,status-update,tool-calls,transfer-destination-request,user-interrupted. You can check the shape of the messages in ServerMessage schema.
+    """
+
+    silence_timeout_seconds: typing_extensions.Annotated[
+        typing.Optional[float], FieldMetadata(alias="silenceTimeoutSeconds")
+    ] = pydantic.Field(default=None)
+    """
+    How many seconds of silence to wait before ending the call. Defaults to 30.
+    
+    @default 30
+    """
+
+    max_duration_seconds: typing_extensions.Annotated[
+        typing.Optional[float], FieldMetadata(alias="maxDurationSeconds")
+    ] = pydantic.Field(default=None)
+    """
+    This is the maximum number of seconds that the call will last. When the call reaches this duration, it will be ended.
+    
+    @default 600 (10 minutes)
+    """
+
+    background_sound: typing_extensions.Annotated[
+        typing.Optional[AssistantBackgroundSound], FieldMetadata(alias="backgroundSound")
+    ] = pydantic.Field(default=None)
+    """
+    This is the background sound in the call. Default for phone calls is 'office' and default for web calls is 'off'.
+    """
+
+    backchanneling_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="backchannelingEnabled")
+    ] = pydantic.Field(default=None)
+    """
+    This determines whether the model says 'mhmm', 'ahem' etc. while user is speaking.
+    
+    Default `false` while in beta.
+    
+    @default false
+    """
+
+    background_denoising_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="backgroundDenoisingEnabled")
+    ] = pydantic.Field(default=None)
+    """
+    This enables filtering of noise and background speech while the user is talking.
+    
+    Default `false` while in beta.
+    
+    @default false
+    """
+
+    model_output_in_messages_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="modelOutputInMessagesEnabled")
+    ] = pydantic.Field(default=None)
+    """
+    This determines whether the model's output is used in conversation history rather than the transcription of assistant's speech.
+    
+    Default `false` while in beta.
+    
+    @default false
+    """
+
+    transport_configurations: typing_extensions.Annotated[
+        typing.Optional[typing.List[TransportConfigurationTwilio]], FieldMetadata(alias="transportConfigurations")
+    ] = pydantic.Field(default=None)
+    """
+    These are the configurations to be passed to the transport providers of assistant's calls, like Twilio. You can store multiple configurations for different transport providers. For a call, only the configuration matching the call transport provider is used.
+    """
+
+    name: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    This is the name of the assistant.
+    
+    This is required when you want to transfer between assistants in a call.
+    """
+
+    first_message: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="firstMessage")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the first message that the assistant will say. This can also be a URL to a containerized audio file (mp3, wav, etc.).
+    
+    If unspecified, assistant will wait for user to speak and use the model to respond once they speak.
+    """
+
+    voicemail_detection: typing_extensions.Annotated[
+        typing.Optional[TwilioVoicemailDetection], FieldMetadata(alias="voicemailDetection")
+    ] = pydantic.Field(default=None)
+    """
+    These are the settings to configure or disable voicemail detection. Alternatively, voicemail detection can be configured using the model.tools=[VoicemailTool].
+    This uses Twilio's built-in detection while the VoicemailTool relies on the model to detect if a voicemail was reached.
+    You can use neither of them, one of them, or both of them. By default, Twilio built-in detection is enabled while VoicemailTool is not.
+    """
+
+    voicemail_message: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="voicemailMessage")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the message that the assistant will say if the call is forwarded to voicemail.
+    
+    If unspecified, it will hang up.
+    """
+
+    end_call_message: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="endCallMessage")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the message that the assistant will say if it ends the call.
+    
+    If unspecified, it will hang up without saying anything.
+    """
+
+    end_call_phrases: typing_extensions.Annotated[
+        typing.Optional[typing.List[str]], FieldMetadata(alias="endCallPhrases")
+    ] = pydantic.Field(default=None)
+    """
+    This list contains phrases that, if spoken by the assistant, will trigger the call to be hung up. Case insensitive.
+    """
+
+    metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
+    """
+    This is for metadata you want to store on the assistant.
+    """
+
+    server_url: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="serverUrl")] = pydantic.Field(
+        default=None
+    )
+    """
+    This is the URL Vapi will communicate with via HTTP GET and POST Requests. This is used for retrieving context, function calling, and end-of-call reports.
+    
+    All requests will be sent with the call object among other things relevant to that message. You can find more details in the Server URL documentation.
+    
+    This overrides the serverUrl set on the org and the phoneNumber. Order of precedence: tool.server.url > assistant.serverUrl > phoneNumber.serverUrl > org.serverUrl
+    """
+
+    server_url_secret: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="serverUrlSecret")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the secret you can set that Vapi will send with every request to your server. Will be sent as a header called x-vapi-secret.
+    
+    Same precedence logic as serverUrl.
+    """
+
+    analysis_plan: typing_extensions.Annotated[typing.Optional[AnalysisPlan], FieldMetadata(alias="analysisPlan")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the plan for analysis of assistant's calls. Stored in `call.analysis`.
+    """
+
+    artifact_plan: typing_extensions.Annotated[typing.Optional[ArtifactPlan], FieldMetadata(alias="artifactPlan")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the plan for artifacts generated during assistant's calls. Stored in `call.artifact`.
+    
+    Note: `recordingEnabled` is currently at the root level. It will be moved to `artifactPlan` in the future, but will remain backwards compatible.
+    """
+
+    message_plan: typing_extensions.Annotated[typing.Optional[MessagePlan], FieldMetadata(alias="messagePlan")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the plan for static predefined messages that can be spoken by the assistant during the call, like `idleMessages`.
+    
+    Note: `firstMessage`, `voicemailMessage`, and `endCallMessage` are currently at the root level. They will be moved to `messagePlan` in the future, but will remain backwards compatible.
+    """
+
+    start_speaking_plan: typing_extensions.Annotated[
+        typing.Optional[StartSpeakingPlan], FieldMetadata(alias="startSpeakingPlan")
+    ] = pydantic.Field(default=None)
+    """
+    This is the plan for when the assistant should start talking.
+    
+    You should configure this if you're running into these issues:
+    
+    - The assistant is too slow to start talking after the customer is done speaking.
+    - The assistant is too fast to start talking after the customer is done speaking.
+    - The assistant is so fast that it's actually interrupting the customer.
+    """
+
+    stop_speaking_plan: typing_extensions.Annotated[
+        typing.Optional[StopSpeakingPlan], FieldMetadata(alias="stopSpeakingPlan")
+    ] = pydantic.Field(default=None)
+    """
+    This is the plan for when assistant should stop talking on customer interruption.
+    
+    You should configure this if you're running into these issues:
+    
+    - The assistant is too slow to recognize customer's interruption.
+    - The assistant is too fast to recognize customer's interruption.
+    - The assistant is getting interrupted by phrases that are just acknowledgments.
+    - The assistant is getting interrupted by background noises.
+    - The assistant is not properly stopping -- it starts talking right after getting interrupted.
+    """
+
+    monitor_plan: typing_extensions.Annotated[typing.Optional[MonitorPlan], FieldMetadata(alias="monitorPlan")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the plan for real-time monitoring of the assistant's calls.
+    
+    Usage:
+    
+    - To enable live listening of the assistant's calls, set `monitorPlan.listenEnabled` to `true`.
+    - To enable live control of the assistant's calls, set `monitorPlan.controlEnabled` to `true`.
+    
+    Note, `serverMessages`, `clientMessages`, `serverUrl` and `serverUrlSecret` are currently at the root level but will be moved to `monitorPlan` in the future. Will remain backwards compatible
+    """
+
+    credential_ids: typing_extensions.Annotated[
+        typing.Optional[typing.List[str]], FieldMetadata(alias="credentialIds")
+    ] = pydantic.Field(default=None)
+    """
+    These are the credentials that will be used for the assistant calls. By default, all the credentials are available for use in the call but you can provide a subset using this.
+    """
+
+    id: str = pydantic.Field()
+    """
+    This is the unique identifier for the assistant.
+    """
+
+    org_id: typing_extensions.Annotated[str, FieldMetadata(alias="orgId")] = pydantic.Field()
+    """
+    This is the unique identifier for the org that this assistant 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 assistant 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
+
+
+update_forward_refs(CallbackStep, Assistant=Assistant)
+update_forward_refs(CreateWorkflowBlockDto, Assistant=Assistant)
+update_forward_refs(HandoffStep, Assistant=Assistant)