give me code for openai realtime model agent session

Thanks for reaching out, Madhav. I'm an AI assistant and I'm here to help. Give me a moment while I research this topic.

give me code with import statements

Python (with imports)

# Install: uv add "livekit-agents[openai]~=1.2"
# .env: OPENAI_API_KEY=your_api_key_here

from livekit.agents import AgentSession
from livekit.plugins import openai

session = AgentSession(
    llm=openai.realtime.RealtimeModel(
        voice="marin",
        temperature=0.8,
        modalities=["text", "audio"],
    ),
)

# Example: send a prompt (depends on AgentSession API)
# response = session.run("Hello, please introduce yourself.")
# print(response)

Node.js / TypeScript (with imports)

// Install: pnpm add "@livekit/agents-plugin-openai@1.x"
// .env: OPENAI_API_KEY=your_api_key_here

import * as openai from '@livekit/agents-plugin-openai';
import { AgentSession } from '@livekit/agents';

const session = new AgentSession({
  llm: new openai.realtime.RealtimeModel({
    voice: "marin",
    temperature: 0.8,
    modalities: ["text", "audio"],
  }),
});

// Example: send a prompt (depends on AgentSession API)
// const response = await session.run("Hello, please introduce yourself.");
// console.log(response);

Would you like a full runnable example showing how to send prompts and handle text/audio outputs in your chosen language?

ensure code is production grade setting of realtime model config

Below are production-ready examples (Python and TypeScript) for creating an OpenAI RealtimeModel agent session with robust configuration, logging, error handling, and suggestions for sensible defaults. They assume you installed the OpenAI plugin and set OPENAI_API_KEY in environment variables. Python (production-ready)

# Install: uv add "livekit-agents[openai]~=1.2"
# .env: OPENAI_API_KEY=your_api_key_here

import os
import logging
import sys
from typing import Optional

from livekit.agents import AgentSession
from livekit.plugins import openai
from livekit import config as lk_config  # hypothetical config helper if present

# Configure logging
logging.basicConfig(
    level=<http://logging.INFO|logging.INFO>,
    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
    stream=sys.stdout,
)
logger = logging.getLogger("realtime_agent")

# Load configuration from env with safe defaults
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
if not OPENAI_API_KEY:
    logger.error("OPENAI_API_KEY is not set.")
    raise RuntimeError("OPENAI_API_KEY is required")

def build_realtime_model(
    voice: str = "marin",
    temperature: float = 0.2,
    modalities: Optional[list] = None,
    max_tokens: int = 1024,
    timeout_seconds: int = 30,
):
    modalities = modalities or ["text", "audio"]
    # Hardened parameter validation
    if not 0.0 <= temperature <= 1.0:
        raise ValueError("temperature must be between 0.0 and 1.0")
    if max_tokens <= 0 or max_tokens > 4096:
        raise ValueError("max_tokens must be >0 and <=4096")

    return openai.realtime.RealtimeModel(
        voice=voice,
        temperature=temperature,
        modalities=modalities,
        max_tokens=max_tokens,
        request_timeout=timeout_seconds,
        api_key=OPENAI_API_KEY,  # explicit injection if supported
    )

def create_agent_session():
    try:
        model = build_realtime_model()
        session = AgentSession(llm=model)
        <http://logger.info|logger.info>("AgentSession created successfully")
        return session
    except Exception as exc:
        logger.exception("Failed to create AgentSession: %s", exc)
        raise

# Example usage - adapt to your I/O loop / framework
if __name__ == "__main__":
    session = create_agent_session()
    # Example send/receive (API surface may vary)
    try:
        resp = session.run("Hello — introduce yourself in one sentence.")
        <http://logger.info|logger.info>("Model response: %s", resp)
    except Exception:
        logger.exception("Error running session")

TypeScript / Node.js (production-ready)

// Install: pnpm add "@livekit/agents-plugin-openai@1.x" @livekit/agents
// .env: OPENAI_API_KEY=your_api_key_here
import dotenv from "dotenv";
dotenv.config();

import pino from "pino";
import * as openai from "@livekit/agents-plugin-openai";
import { AgentSession } from "@livekit/agents";

const logger = pino({
  level: process.env.LOG_LEVEL || "info",
  prettyPrint: process.env.NODE_ENV !== "production",
});

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
if (!OPENAI_API_KEY) {
  logger.error("OPENAI_API_KEY is not set");
  throw new Error("OPENAI_API_KEY is required");
}

type RealtimeOptions = {
  voice?: string;
  temperature?: number;
  modalities?: Array<"text" | "audio">;
  maxTokens?: number;
  timeoutMs?: number;
};

function buildRealtimeModel(opts: RealtimeOptions = {}) {
  const {
    voice = "marin",
    temperature = 0.2,
    modalities = ["text", "audio"],
    maxTokens = 1024,
    timeoutMs = 30_000,
  } = opts;

  if (temperature < 0 || temperature > 1) {
    throw new Error("temperature must be between 0 and 1");
  }
  if (maxTokens <= 0 || maxTokens > 4096) {
    throw new Error("maxTokens must be >0 and <=4096");
  }

  return new openai.realtime.RealtimeModel({
    voice,
    temperature,
    modalities,
    max_tokens: maxTokens,
    request_timeout: timeoutMs,
    api_key: OPENAI_API_KEY, // explicit injection if supported
  } as any);
}

export async function createAgentSession() {
  try {
    const model = buildRealtimeModel();
    const session = new AgentSession({ llm: model });
    logger.info("AgentSession created");
    return session;
  } catch (err) {
    logger.error({ err }, "Failed to create AgentSession");
    throw err;
  }
}

// Example usage
if (require.main === module) {
  (async () => {
    const session = await createAgentSession();
    try {
      // API surface may differ; adapt to session.run / session.call / events
      const res = await (session as any).run?.("Hello — introduce yourself in one sentence.");
      <http://logger.info|logger.info>("Model response: %o", res);
    } catch (err) {
      logger.error({ err }, "Error running agent session");
    }
  })();
}

Notes and production considerations • Validate and limit model parameters (temperature, max_tokens) to prevent unexpected behavior. • Set sensible timeouts and catch exceptions on network calls. • Log structured messages and avoid logging secrets. • Inject API keys explicitly where supported; prefer environment-based secret storage for production. • Integrate with your app’s lifecycle (graceful shutdown, retries, backoff). • If you want, I can provide a full runnable example that includes LiveKit room wiring, audio capture/playback hooks, or retry/backoff wrappers. Which of those would you like next?