from livekit.agents import Agent

agent = Agent(
  instructions="You are a friendly receptionist at Bright Smile Dental clinic.",
  tts_text_transforms=["filter_markdown", "filter_emoji"],
)

instructions = """You are a friendly receptionist at Bright Smile Dental clinic.

SCOPE: You help with appointment scheduling, clinic hours, location,
insurance questions, and general dental visit information.

BOUNDARIES:
- If asked about topics outside dental clinic operations, politely redirect:
"I'm only able to help with Bright Smile Dental appointments and information.
Is there something I can help you with regarding your dental care?"
- Never provide medical advice or diagnoses. If a caller describes symptoms,
say: "That sounds like something our dentists should look at. Would you
like me to book an appointment?"
- Never share information about other patients.
- If a caller is abusive, remain calm and professional. Offer to transfer
to office staff if available.

STYLE:
- Keep responses to 1-2 sentences when possible.
- Never use markdown, emojis, or formatting.
- Use natural spoken language, not written language."""

from livekit.agents import Agent

agent = Agent(
  instructions="...",
  user_away_timeout=30.0,  # seconds
)

from livekit.agents import Agent

class DentalReceptionist(Agent):
  def __init__(self):
      super().__init__(
          instructions="...",
          user_away_timeout=30.0,
      )

  async def on_user_away_timeout(self):
      await self.session.say(
          "Are you still there? I'm here if you need help with anything.",
          allow_interruptions=True,
      )
      # If they still don't respond, the next timeout will fire again

from livekit.agents import Agent

class DentalReceptionist(Agent):
  async def on_enter(self):
      # say() with a static string can be cached by the TTS engine
      # This fires immediately without waiting for LLM generation
      await self.session.say(
          "Thanks for calling Bright Smile Dental! How can I help you today?",
          allow_interruptions=True,
      )

from livekit.agents import BackgroundAudioPlayer, Agent

class DentalReceptionist(Agent):
  async def on_enter(self):
      self.bg_audio = BackgroundAudioPlayer(
          audio_url="https://example.com/hold-music.mp3",
          loop=True,
          volume=0.3,
      )
      await self.bg_audio.start(self.session.room)

      await self.session.say(
          "Thanks for calling Bright Smile Dental! How can I help you today?",
          allow_interruptions=True,
      )

      # Stop background audio when the conversation starts
      await self.bg_audio.stop()

from livekit.agents import (
  Agent,
  AgentServer,
  AgentSession,
  BackgroundAudioPlayer,
  MultilingualModel,
  RunContext,
  TurnHandlingOptions,
  function_tool,
)
from livekit.plugins import openai, deepgram, cartesia, silero

server = AgentServer()


# --- Tools ---

@function_tool
async def check_availability(context: RunContext, date: str) -> str:
  """Check available appointment slots for a given date.

  Args:
      date: The date to check availability for (e.g., "next Tuesday", "March 15")
  """
  available_slots = ["9:00 AM", "11:30 AM", "2:00 PM", "4:30 PM"]
  return f"Available slots for {date}: {', '.join(available_slots)}"


@function_tool
async def book_appointment(context: RunContext, name: str, date: str, time: str) -> str:
  """Book an appointment for a patient.

  Args:
      name: Patient's full name
      date: Desired appointment date
      time: Desired appointment time
  """
  agent: DentalReceptionist = context.agent
  booking = {"name": name, "date": date, "time": time}

  # Update frontend state
  await agent.update_agent_state("booking", patient_name=name)

  # Store in session
  context.session.userdata["last_booking"] = booking

  # Send text stream confirmation to frontend
  await agent.send_booking_confirmation(booking)

  # Update state to confirmed
  await agent.update_agent_state("confirmed", patient_name=name)

  return f"Appointment booked for {name} on {date} at {time}."


# --- Agent ---

class DentalReceptionist(Agent):
  def __init__(self):
      super().__init__(
          instructions="""You are a friendly receptionist at Bright Smile Dental clinic.

SCOPE: Help with appointment scheduling, clinic hours, location,
insurance questions, and general dental visit information.

BOUNDARIES:
- If asked about topics outside dental clinic operations, politely redirect.
- Never provide medical advice. Suggest booking an appointment instead.
- Never share information about other patients.

STYLE:
- Keep responses to 1-2 sentences when possible.
- Never use markdown, emojis, or formatting.
- Use natural spoken language.""",
          tools=[check_availability, book_appointment],
          turn_handling=TurnHandlingOptions(
              turn_detection=MultilingualModel(),
              min_endpointing_delay=0.5,
              max_endpointing_delay=1.5,
              interruption_mode="adaptive",
              false_interruption_timeout=0.6,
              resume_false_interruption=True,
          ),
          tts_text_transforms=["filter_markdown", "filter_emoji"],
          user_away_timeout=30.0,
      )

  async def on_enter(self):
      # Inject returning patient info if available
      patient_info = self.session.userdata.get("patient_info")
      if patient_info:
          ctx = self.chat_ctx.copy()
          ctx.add_message(
              role="system",
              content=f"Returning patient: {patient_info['name']}, "
                      f"last visit: {patient_info['last_visit']}",
          )
          await self.update_chat_ctx(ctx)

      # Set initial state for frontend
      await self.update_agent_state("greeting")

      # Fast cached greeting
      await self.session.say(
          "Thanks for calling Bright Smile Dental! How can I help you today?",
          allow_interruptions=True,
      )

  async def on_user_away_timeout(self):
      await self.session.say(
          "Are you still there? I'm here if you need help.",
          allow_interruptions=True,
      )

  async def send_booking_confirmation(self, booking: dict):
      stream = await self.session.room.local_participant.stream_text(
          topic="booking-confirmation",
      )
      await stream.write(
          f"Booking confirmed: {booking['name']} on {booking['date']} "
          f"at {booking['time']}. Bright Smile Dental, 123 Main St."
      )
      await stream.close()

  async def update_agent_state(self, state: str, **extra):
      attributes = {"agent_state": state}
      attributes.update(extra)
      await self.session.room.local_participant.set_attributes(attributes)


# --- Entrypoint ---

@server.rtc_session
async def entrypoint(session: AgentSession):
  await session.start(
      agent=DentalReceptionist(),
      room=session.room,
      stt=deepgram.STT(model="nova-3"),
      llm=openai.LLM(model="gpt-4o-mini"),
      tts=cartesia.TTS(voice="<your-voice-id>"),
  )


if __name__ == "__main__":
  server.run()