description: >
  An smart voicemail capable of qualifying a lead
  and scheduling an appointment (cal.com).

variables:
  $cal: # cal.com
    auth: <cal.com-auth-token>
    username: <cal.com-username>
    eventTypeSlug: <cal.com-event-type-slug>
    eventTypeId: <cal.com-event-type-id>
    timeZone: Europe/Paris

  $openai:
    key: <your-openai-key>
    model: gpt-4o

  # voicebot prompt
  $messages:
    - role: developer
      content: >
        You are the intelligent answering machine for the TOP REAL ESTATE agency,
        located at 128 rue La Boétie, 75008, Paris.

        The agency's hours are:
          - Monday to Friday from 9am to 5pm
          - Saturday from 10am to 4pm
          - excluding public holidays

        The agency manager is Jean-Michel Mal-Logé. The staff are:
        - Sarah Pelle
        - Sarah Croche

        Your goal is to qualify the call. For example, the caller might be calling to:
        - Sell a property
        - Buy a property
        - Follow up on an ongoing file
        - Schedule an appointment
        - Inquire about the agency's hours

        If they call regarding a property or to schedule an appointment, ask questions to
        qualify their request and the property: location, area, desired price, etc.
        You must qualify their request as precisely as possible.

        If you are asked to call back, say that you will forward the information to the agency.
        If an appointment is requested, you can call the function "get_calendar_slot" to check
        availability. When listing available times to the caller, provide a maximum of 3 options.

        The booking is arranged over the phone with you. If the appointment is confirmed,
        tell them that they will receive a confirmation SMS.

        - Make sure to be humorous and witty!
        - Ensure that all your responses are short and simple. Use colloquial language.
        - This is a spoken conversation. Do not reply in markdown.
        - Do not use emojis (due to voice synthesis).

        You have the following functions (tools) available:

        - dial: to transfer the call to a human. phone_number = '+15559820800'. You can use it at the caller's request.
        - hangup: when the conversation is over, you can hang up.
        - get_calendar_slot: checks availability in the calendar.
    - role: developer
      content: >
        Today is ${{ now.toISOString() }}.
        Caller number: ${{ call.fromNumber }}.
    # all messages with role "assistant" will be spoken by the bot at the start of the call
    - role: assistant
      content: >
        Hello, I am Maria, the virtual assistant of TOP REAL ESTATE agency.
        How can I help you?

  # to extract information at the end of the call
  $ai: >
    Can you reply with a JSON object containing the following properties:
    {
      "short": "summary of the conversation in a few words",
      "long": "summary of the conversation in a few sentences",
      "booked": bool (true/false if an appointment is booked),
      "booked_date": "ISO 8601 if an appointment is booked",
      "sms": "(compose an SMS to send to the caller)"
    }

  $emails:
    - [email protected]

defaults:
  language: en-US

branches:
  inbound-call:
    actions:
      - action: voicebot@v1
        params:
          pleaseWait:
            # if the bot takes more than 2s (configurable) to respond,
            # the following phrases will be spoken
            enabled: true
            delay: 2
            sentences:
              - please hold on
              - one moment please
              - okay, one moment please
          initialMessages: ${{ $messages }}
          engine:
            name: OpenAI
            model: ${{ $openai.model }}
            auth: ${{ $openai.key }}
            params:
              maxCompletionTokens: 0 # default
              temperature: 0.2 # default
            # url: https://openai.compatible.endpoint

          # the tools defined here are HTTP endpoints that will be called directly by the bot
          tools:
            - name: get_calendar_slot
              url: https://api.cal.com/v2/slots?username=${{ $cal.username }}&eventTypeSlug=${{ $cal.eventTypeSlug }}&timeZone=${{ $cal.timeZone }}
              description: Returns a list of available slots
              method: GET
              headers:
                Authorization: Bearer ${{ $cal.auth }}
                cal-api-version: 2024-09-04
              # the parameters are automatically filled by the bot
              params:
                - name: start
                  type: string
                  description: ISO8601 date-time (start).
                - name: end
                  type: string
                  description: ISO8601 date-time (end).

            - name: book_slot
              url: https://api.cal.com/v2/bookings
              description: Books a slot for an appointment
              headers:
                Authorization: Bearer ${{ $cal.auth }}
                cal-api-version: 2024-08-13
              method: POST
              params:
                # each parameter must be defined with a JSON SCHEMA
                # https://platform.openai.com/docs/guides/function-calling?api-mode=chat#defining-functions
                # https://json-schema.org/
                - name: attendee
                  type: object
                  description: caller information
                  additionalProperties: false
                  required:
                    - phoneNumber
                    - name
                    - timeZone
                    - email
                  properties:
                    phoneNumber:
                      type: string
                      description: Phone number in E.164
                    name:
                      type: string
                      description: Caller name. Use phone number if empty.
                    timeZone:
                      type: string
                      description: IANA timezone, use ${{ $cal.timeZone }}
                    email:
                      type: string
                      description: use noreply+(phoneNumber)@example.com
                - name: start
                  type: string
                  description: Slot ISO8601 date-time start
                - name: eventTypeId
                  type: number
                  description: Use ${{ $cal.eventTypeId }}
        result: $bot

      # if the bot wishes to call the builtin tool "dial",
      # the number to call is in $bot.payload
      - if: $bot?.exitTool === 'dial' && $bot?.payload.match(/^\+/)
        then:
          - action: dial@v1
            params:
              targets:
                - number: ${{ $bot?.payload }}
                  timeout: 30

      # if the bot wishes to hang up
      - if: $bot?.exitTool === 'hangup'
        then:
          - action: say@v2
            params:
              what: Goodbye, see you soon
          - action: hangup@v1

  hangup:
    actions:
      # the conversation history (in OpenAI format)
      # is in $bot.messages
      - if: "!$bot?.messages?.length"
        goto:
          branch: exit

      # we add a message to extract information
      # using $ai
      - action: javascript@v1
        params:
          code: |
            const $messages = $bot.messages
            $messages.push({
              role: 'developer',
              content: $ai
            })
            return {
              $messages
            }

      # we call OpenAI in one-shot by passing the entire history
      # plus the $ai prompt added above
      - action: openai@v2
        params:
          secret: ${{ $openai.key }}
          endpoint: chat/completions
          timeout: 60
          properties:
            model: ${{ $openai.model }}
            messages: ${{ $messages }}
            response_format:
              type: json_object
        result: $openai

      # we parse the JSON response and create 3 new variables
      - action: javascript@v1
        params:
          code: |
            const res = JSON.parse($openai.choices[0].message.content)
            return {
              $sms: res.sms,
              $short: res.short,
              $long: res.long
            }

      # we send a summary via email
      - if: $short && $long
        then:
          - action: email@v1
            params:
              subject: Missed call from ${{ call.fromNumber }} - ${{ $short }}
              text: |
                Missed call from ${{ call.fromNumber }}

                ${{ $long }}

                Regards.
              to: ${{ $emails }}

      # if the caller is on a mobile phone, also send them a summary
      - if: $sms && call.fromType.match(/MOBILE/)
        then:
          - action: sms@v1
            params:
              to:
                - ${{ call.fromNumber }}
              body: ${{ $sms }}

tools:
  - name: get_calendar_slot
    method: GET
    url: https://api.example.com/calendar/slots
    headers:
      Authorization: Bearer ${{ $calendar.auth }}
    params:
      - name: start
        type: string
        description: ISO8601 date
      - name: end
        type: string
        description: ISO8601 date