Prism SDK reference

async with client.realtime.connect(
    endpoint="wss://prism.api.rime.ai/v1/realtime",
    voice="aurora",
    instructions="You answer the phone for Juniper Cafe.",
) as session:
    capture = asyncio.create_task(stream_microphone(session))
    try:
        async for event in session.events:
            handle(event.payload)
    finally:
        capture.cancel()

const session = await client.realtime.connect({
  endpoint: "wss://prism.api.rime.ai/v1/realtime",
  voice: "aurora",
  instructions: "You answer the phone for Juniper Cafe.",
});
const capture = new AbortController();
try {
  void streamMicrophone(session, capture.signal);
  for await (const event of session.events) {
    handle(event.payload);
  }
} finally {
  capture.abort();
  await session.close();
}

session, err := client.Realtime.Connect(ctx, rime.RealtimeConnectOptions{
	Voice:        "aurora",
	Instructions: "You answer the phone for Juniper Cafe.",
})
if err != nil {
	return err
}
defer session.Close()
captureCtx, stopCapture := context.WithCancel(ctx)
defer stopCapture()
go streamMicrophone(captureCtx, session)
for {
	event, err := session.Recv(ctx)
	if err == io.EOF {
		return nil
	}
	if err != nil {
		return err
	}
	handle(event.Payload)
}

let options = RealtimeConnectOptions::default()
    .voice("aurora")
    .instructions("You answer the phone for Juniper Cafe.");
let session = client.realtime().connect(options).await?;
let capture = tokio::spawn(stream_microphone(session.clone()));
let mut events = session.events()?;
let result = async {
    while let Some(event) = events.next().await {
        handle(event?.payload);
    }
    Ok::<_, rimelabs_sdk::Error>(())
}
.await;
capture.abort();
session.close().await;
result?;

from rimelabs_sdk.realtime import run_conversation

await run_conversation(session, source=microphone, playback=speaker, on_event=show)

import { runConversation } from "@rimelabs/sdk";

await runConversation(session, { source: microphone, playback: speaker, onEvent: show, signal });

runner := rime.ConversationRunner{Session: session, Source: microphone, Playback: speaker, OnEvent: show}
err := runner.Run(ctx)

use rimelabs_sdk::realtime::ConversationRunner;

ConversationRunner::new(session, microphone, speaker).on_event(show).run(stop).await?;

from rimelabs_sdk.realtime import ToolDefinition

get_hours = ToolDefinition(
    name="get_hours",
    description="Look up the cafe's opening hours for a day of the week.",
    parameters={
        "type": "object",
        "properties": {"day": {"type": "string"}},
        "required": ["day"],
    },
)

import type { ToolDefinition } from "@rimelabs/sdk";

const getHours: ToolDefinition = {
  name: "get_hours",
  description: "Look up the cafe's opening hours for a day of the week.",
  parameters: {
    type: "object",
    properties: { day: { type: "string" } },
    required: ["day"],
  },
};

info = await session.update(
    instructions="Handle billing. Use only the supplied tools.",
    tools=[refund_tool],
)

const info = await session.update({
  instructions: "Handle billing. Use only the supplied tools.",
  tools: [refundTool],
});

from rimelabs_sdk.realtime import AudioChunk, PCMFormat

await session.send_audio(
    AudioChunk(data=frame, format=PCMFormat(sample_rate=48000, channels=2))
)

await session.sendAudio({ data: frame, format: { sampleRate: 48000, channels: 2 } });

reply = await session.send_text("What time do you close today?")
check_in = await session.request_reply(instruction="Ask whether the caller is still there.")
item = await session.add_message("assistant", "Thanks for calling Juniper Cafe.")

const reply = await session.sendText("What time do you close today?");
const checkIn = await session.requestReply({ instruction: "Ask whether the caller is still there." });
const item = await session.addMessage("assistant", "Thanks for calling Juniper Cafe.");

from rimelabs_sdk.realtime import HistoryMessage

note = await session.create_item(
    HistoryMessage(role="system", text="The caller has a pickup order at 10 a.m.")
)
items = await session.get_history()
await session.delete_item(note.item_id)

const note = await session.createItem({
  type: "message",
  role: "system",
  text: "The caller has a pickup order at 10 a.m.",
});
const items = await session.getHistory();
await session.deleteItem(note.itemId);

note, err := session.CreateItem(ctx, rime.HistoryItem{
	Type: rime.HistoryMessage,
	Role: "system",
	Text: "The caller has a pickup order at 10 a.m.",
}, "")
if err != nil {
	return err
}
items, err := session.GetHistory(ctx)
if err != nil {
	return err
}
if err := session.DeleteItem(ctx, note.ItemID()); err != nil {
	return err
}

use rimelabs_sdk::realtime::{HistoryItem, HistoryRole};

let note = session
    .create_item(
        HistoryItem::Message {
            id: None,
            role: HistoryRole::System,
            text: "The caller has a pickup order at 10 a.m.".into(),
        },
        None,
    )
    .await?;
let items = session.get_history().await?;
session.delete_item(note.item_id()).await?;

from rimelabs_sdk.realtime import HistoryFunctionCall, HistoryFunctionResult

await session.create_item(
    HistoryFunctionCall(
        call_id="call_hours_1",
        name="get_hours",
        arguments=json.dumps({"day": "Monday"}),
    )
)
await session.create_item(
    HistoryFunctionResult(call_id="call_hours_1", output=json.dumps({"closes": "4 p.m."}))
)

await session.createItem({
  type: "function_call",
  callId: "call_hours_1",
  name: "get_hours",
  arguments: JSON.stringify({ day: "Monday" }),
});
await session.createItem({
  type: "function_call_output",
  callId: "call_hours_1",
  output: JSON.stringify({ closes: "4 p.m." }),
});

for item in saved:
    await new_session.create_item(item)

for (const item of saved) {
  await newSession.createItem(item);
}

# On a ToolCall event:
output = json.dumps(await run_tool(payload.name, payload.arguments))
await session.submit_tool_result(payload.call, output)

# On the ResponseEnded event of the reply that made the call:
continuation = await session.continue_reply(payload.response)

// On a "tool.call" event:
const output = JSON.stringify(await runTool(payload.name, payload.arguments));
await session.submitToolResult(payload.call, output);

// On the "response.ended" event of the reply that made the call:
const continuation = await session.continueReply(payload.response);

from rimelabs_sdk.realtime import PlaybackFinished, PlaybackInterrupted

await session.report_playback(PlaybackInterrupted(output=output, audio_end_ms=1200))
await session.report_playback(PlaybackFinished(response=response))

await session.reportPlayback({ kind: "interrupted", output, audioEndMs: 1200 });
await session.reportPlayback({ kind: "finished", response });

from rimelabs_sdk.realtime import AudioDelta, ResponseEnded, TextDelta

async for event in session.events:
    payload = event.payload
    if isinstance(payload, TextDelta):
        print(payload.delta, end="")
    elif isinstance(payload, AudioDelta):
        play(payload.audio.data)
    elif isinstance(payload, ResponseEnded):
        print(payload.status, payload.reason)

for await (const { payload } of session.events) {
  switch (payload.kind) {
    case "text.delta":
      process.stdout.write(payload.delta);
      break;
    case "audio.delta":
      play(payload.audio.data);
      break;
    case "response.ended":
      console.log(payload.status, payload.reason);
      break;
  }
}

from rimelabs_sdk.realtime import RealtimeTimeouts

timeouts = RealtimeTimeouts(connect_s=5, ready_s=15, request_s=10)

import type { RealtimeTimeouts } from "@rimelabs/sdk";

const timeouts: RealtimeTimeouts = { connectS: 5, readyS: 15, requestS: 10 };

from rimelabs_sdk.realtime import RimeRealtimeError

try:
    await session.send_text("What time do you close today?")
except RimeRealtimeError as error:
    print(error.fault.code, error.fault.correlation_id)

import { RimeRealtimeError } from "@rimelabs/sdk";

try {
  await session.sendText("What time do you close today?");
} catch (error) {
  if (!(error instanceof RimeRealtimeError)) throw error;
  console.log(error.fault.code, error.fault.correlationId);
}