Let Prism call your tools

import asyncio

from rimelabs_sdk.realtime import ToolDefinition

GET_OPENING_HOURS = ToolDefinition(
    name="get_opening_hours",
    description="Look up Juniper Cafe's opening hours for one day of the week.",
    parameters={
        "type": "object",
        "properties": {"day": {"type": "string", "description": "A day of the week"}},
        "required": ["day"],
    },
)

async def handle_call(client, microphone):
    async with client.realtime.connect(
        endpoint="wss://prism.api.rime.ai/v1/realtime",
        voice="aurora",
        instructions=(
            "You answer the phone for Juniper Cafe. "
            "Call get_opening_hours before you answer a question about opening hours."
        ),
        tools=[GET_OPENING_HOURS],
    ) as session:
        capture = asyncio.create_task(stream_caller_audio(session, microphone))
        try:
            await run_tools(session)
        finally:
            capture.cancel()

import asyncio
import json

from rimelabs_sdk import RimeInputError
from rimelabs_sdk.realtime import ResponseEnded, RimeRealtimeError, ToolCall


async def run_tool(session, call):
    day = call.arguments.get("day")
    try:
        if call.name == "get_opening_hours" and isinstance(day, str):
            result = await get_opening_hours(day)  # Your own lookup
        else:
            result = {"error": f"Can't run {call.name} with these arguments"}
    except Exception:  # A call whose lookup fails still gets a result.
        result = {"error": f"{call.name} failed"}
    await session.submit_tool_result(call.call, json.dumps(result))


async def finish_round(session, response, runs):
    await asyncio.gather(*runs)  # Every call has its result.
    try:
        await session.continue_reply(response)
    except RimeInputError:
        pass  # The caller spoke first, and Prism is answering them instead.
    except RimeRealtimeError as error:
        if error.fault.code not in ("tool_continuation_unavailable", "response_superseded"):
            raise  # Otherwise the caller spoke first, or Prism had closed the round.


async def run_tools(session):
    rounds = {}  # The tool runs of each reply that made calls
    async with asyncio.TaskGroup() as tasks:
        async for event in session.events:
            payload = event.payload
            if isinstance(payload, ToolCall):
                run = tasks.create_task(run_tool(session, payload))
                rounds.setdefault(payload.call.response_id, []).append(run)
            elif isinstance(payload, ResponseEnded):
                runs = rounds.pop(payload.response.response_id, None)
                if runs and payload.status == "completed":
                    tasks.create_task(finish_round(session, payload.response, runs))

from rimelabs_sdk.realtime import PrismFiller, ToolDefinition

GET_OPENING_HOURS = ToolDefinition(
    name="get_opening_hours",
    description="Look up Juniper Cafe's opening hours for one day of the week.",
    parameters={
        "type": "object",
        "properties": {"day": {"type": "string", "description": "A day of the week"}},
        "required": ["day"],
    },
    prism_filler=PrismFiller(type="text", text="One moment while I check our hours."),
)