Skip to content

Send a phone call from AI agent, in an API call. Or, directly call the bot from the configured phone number!

Python
6.1 KB
Raw Blame
import asyncio
import random
import string
from datetime import UTC, datetime, tzinfo
from typing import Any
from uuid import UUID, uuid4

from pydantic import BaseModel, Field, ValidationInfo, field_validator

from app.helpers.config_models.conversation import (
    LanguageEntryModel,
    WorkflowInitiateModel,
)
from app.helpers.monitoring import tracer
from app.helpers.pydantic_types.phone_numbers import PhoneNumber
from app.models.message import (
    ActionEnum as MessageActionEnum,
    MessageModel,
    PersonaEnum as MessagePersonaEnum,
    StyleEnum as MessageStyleEnum,
)
from app.models.next import NextModel
from app.models.reminder import ReminderModel
from app.models.synthesis import SynthesisModel
from app.models.training import TrainingModel


class CallInitiateModel(WorkflowInitiateModel):
    phone_number: PhoneNumber


class CallGetModel(BaseModel):
    # Immutable fields
    call_id: UUID = Field(default_factory=uuid4, frozen=True)
    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC), frozen=True)
    # Editable fields
    in_progress: bool = False
    initiate: CallInitiateModel = Field(frozen=True)
    claim: dict[
        str, Any
    ] = {}  # Place after "initiate" as it depends on it for validation
    messages: list[MessageModel] = []
    next: NextModel | None = None
    reminders: list[ReminderModel] = []
    synthesis: SynthesisModel | None = None

    @field_validator("claim")
    @classmethod
    def _validate_claim(
        cls, claim: dict[str, Any] | None, info: ValidationInfo
    ) -> dict[str, Any]:
        """
        Validate the claim field against the initiate data model.
        """
        initiate: CallInitiateModel | None = info.data.get("initiate", None)
        if not initiate:
            return {}
        return (
            initiate.claim_model()
            .model_validate(claim)
            .model_dump(
                exclude_none=True,
                mode="json",  # Field must be serialized as JSON in other parts of the code
            )
        )

    @field_validator("messages")
    @classmethod
    def _validate_messages(cls, messages: list[MessageModel]) -> list[MessageModel]:
        """
        Merge messages with the same persona.
        """

        # Skip if there are no messages
        if not messages:
            return messages

        # Iterate over the messages
        merged: list[MessageModel] = [messages[0]]
        for new_message in messages[1:]:
            # If the last message is not from the same persona or action, keep it as is
            last = merged[-1]
            if last.persona != new_message.persona or last.action != new_message.action:
                merged.append(new_message)
                continue

            # Merge the content and tool calls
            last.content = (last.content + " " + new_message.content).strip()
            last.tool_calls = list({*last.tool_calls, *new_message.tool_calls})
            # Override the style
            last.style = new_message.style

        return merged


class CallStateModel(CallGetModel, extra="ignore"):
    # Immutable fields
    callback_secret: str = Field(
        default="".join(
            random.choice(string.ascii_letters + string.digits) for _ in range(16)
        ),
        frozen=True,
    )
    # Editable fields
    lang_short_code: str | None = None
    last_interaction_at: datetime | None = None
    recognition_retry: int = 0
    voice_id: str | None = None

    @property
    def lang(self) -> LanguageEntryModel:  # pyright: ignore
        default = self.initiate.lang.default_lang
        if self.lang_short_code:
            return next(
                (
                    lang
                    for lang in self.initiate.lang.availables
                    if lang.short_code == self.lang_short_code
                ),
                default,
            )
        return default

    async def trainings(self, cache_only: bool = True) -> list[TrainingModel]:
        """
        Get the trainings from the last messages.

        Is using query expansion from last messages. Then, data is sorted by score.
        """
        from app.helpers.config import CONFIG

        with tracer.start_as_current_span("call_trainings"):
            search = CONFIG.ai_search.instance
            tasks = await asyncio.gather(
                *[
                    search.training_search_all(
                        cache_only=cache_only,
                        lang=self.lang.short_code,
                        text=message.content,
                    )
                    for message in self.messages[
                        -CONFIG.ai_search.expansion_n_messages :
                    ]
                ],
            )  # Get trainings from last messages
            trainings = sorted(
                set(
                    training
                    for trainings in tasks
                    for training in trainings or []
                    if training.score >= CONFIG.ai_search.strictness
                )
            )  # Flatten, remove duplicates, sort by score, filter by strictness
            return trainings

    def tz(self) -> tzinfo:
        """
        Get the timezone of the phone number.
        """
        return PhoneNumber.tz(self.initiate.phone_number)

    def last_assistant_style(self) -> MessageStyleEnum:
        """
        Get the last assistant message style.
        """
        inverted_messages = self.messages.copy()
        inverted_messages.reverse()
        for message in inverted_messages:
            if message.persona != MessagePersonaEnum.ASSISTANT:
                continue
            return message.style
        return MessageStyleEnum.NONE

    def had_interaction(self) -> bool:
        """
        Check if the call had an interaction.

        An interaction is defined as a call with a human message.
        """
        return not (
            len(self.messages) >= 3  # noqa: PLR2004
            and self.messages[-3].action == MessageActionEnum.CALL
            and self.messages[-2].persona == MessagePersonaEnum.ASSISTANT
            and self.messages[-1].action == MessageActionEnum.HANGUP
        )