Overview

// Mute - sends silence to keep connection stable
agent.mute();

// Unmute - resumes sending real audio
agent.unmute();

// Check current state
if (agent.isMuted()) {
  showMutedIcon();
}

const agent = new ConversationAgent({
  // ... config
  transcriptCallback: async (msg) => {
    // Handle thinking state
    if (msg.content === "thinking_started") {
      showLoadingSpinner();
      return;
    }
    if (msg.content === "thinking_completed") {
      hideLoadingSpinner();
      return;
    }

    // Regular transcript
    addToChat(msg.role, msg.content);
  },
});

mcp::<widget_url>::<widget_data_json>

mcp::https://widgets.example.com/food-cart.html::{"items":[...],"total":450}

interface CurrentWidget {
  url: string;
  data: Record<string, unknown>;
}

const [currentWidget, setCurrentWidget] = useState<CurrentWidget | null>(null);
const currentWidgetRef = useRef<CurrentWidget | null>(null);
const iframeRef = useRef<HTMLIFrameElement | null>(null);

const agent = new ConversationAgent({
  // ... config
  transcriptCallback: async (msg) => {
    // Handle MCP widget messages: mcp::<url>::<data>
    if (msg.role === "bot" && msg.content.startsWith("mcp::")) {
      const parts = msg.content.slice(5).split("::");
      if (parts.length >= 2) {
        const widgetUrl = parts[0];
        const widgetData = JSON.parse(parts.slice(1).join("::"));
        const widget = { url: widgetUrl, data: widgetData };
        currentWidgetRef.current = widget;
        setCurrentWidget(widget);
        return;
      }
    }

    // Regular transcript
    addToChat(msg.role, msg.content);
  },
});

const handleIframeLoad = useCallback(() => {
  const widget = currentWidgetRef.current;
  if (!iframeRef.current?.contentWindow || !widget) return;

  iframeRef.current.contentWindow.postMessage(
    {
      jsonrpc: "2.0",
      method: "ui/initialize",
      params: {
        toolOutput: widget.data,
        data: widget.data,
        theme: "dark",
        hostContext: { theme: "dark" },
      },
    },
    "*",
  );
}, []);

{
  currentWidget && (
    <iframe
      ref={iframeRef}
      src={currentWidget.url}
      sandbox="allow-scripts allow-same-origin"
      onLoad={handleIframeLoad}
    />
  );
}

const agent = new ConversationAgent({
  // ... config
  stateCallback: (newState, previousState) => {
    switch (newState) {
      case AgentState.CONNECTING:
        showSpinner();
        break;
      case AgentState.LISTENING:
        showListeningIndicator();
        break;
      case AgentState.SPEAKING:
        showSpeakingAnimation();
        break;
      case AgentState.ERROR:
        showErrorMessage();
        break;
    }
  },
});

// Or check programmatically
const currentState = agent.getState();

const agent = new ConversationAgent({
  // ... config (InteractionType.CALL)
  transcriptCallback: async (msg) => {
    if (msg.role === Role.USER) {
      addToChat("You", msg.content);
    } else if (msg.role === Role.BOT) {
      addToChat("Agent", msg.content);
    }
  },
});

const agent = new ConversationAgent({
  // ... config (InteractionType.CHAT)
  textCallback: async (msg) => {
    addToChat("Agent", msg.text);
  },
});

import newrelic from "newrelic";

const SKIP_EVENTS = new Set(["user_interrupted", "state_changed"]);

const agent = new ConversationAgent({
  // ... config
  telemetryCallback: (event) => {
    if (SKIP_EVENTS.has(event.name)) return;

    newrelic.recordCustomEvent(`SarvamSDK_${event.name}`, {
      ...event.properties,
      sessionId: event.sessionId,
      interactionId: event.interactionId,
      timestamp: event.timestamp,
    });
  },
});

// Start the conversation
await agent.start();

// Wait for connection (timeout in seconds)
const connected = await agent.waitForConnect(10);
if (!connected) {
  console.error("Connection timeout");
  return;
}

// Check connection status
if (agent.isConnected()) {
  console.log("Connected");
}

// Get the interaction ID
const interactionId = agent.getInteractionId();

// Set a reference ID (e.g., telephony Call SID)
agent.reference_id = "CA1234567890abcdef";

// Wait for disconnection (blocks until conversation ends)
await agent.waitForDisconnect();

// Stop and cleanup
await agent.stop();

const config = {
  // ... other config
  initial_language_name: SarvamToolLanguageName.HINDI,
};

new ConversationAgent({
  apiKey: string;
  config: InteractionConfig;
  audioInterface?: AsyncAudioInterface;  // Required for CALL mode
  textCallback?: (msg) => Promise<void>;
  transcriptCallback?: (msg) => Promise<void>;
  audioCallback?: (msg) => Promise<void>;
  audioLevelCallback?: (level) => void;
  eventCallback?: (event) => Promise<void>;
  stateCallback?: (newState, prevState) => void;
  telemetryCallback?: (event) => void;
  startCallback?: () => Promise<void>;
  endCallback?: () => Promise<void>;
  baseUrl?: string;
  platform?: 'browser' | 'react-native';
})

try {
  await agent.start();
} catch (err) {
  if (err instanceof RateLimitError) {
    console.log(`Rate limited. Retry after ${err.retryAfter} seconds`);
    await new Promise((r) => setTimeout(r, err.retryAfter * 1000));
    await agent.start();
  } else if (err instanceof AuthenticationError) {
    console.error("Invalid API key");
  } else if (err instanceof ForbiddenError) {
    console.error("Access denied - check your permissions");
  } else if (err instanceof NotFoundError) {
    console.error("App not found - check app_id");
  } else if (err instanceof ServerError) {
    console.error("Server error - try again later");
  } else if (err instanceof SDKError) {
    console.error(`SDK error [${err.code}]: ${err.message}`);
  } else {
    console.error("Unexpected error:", err);
  }
}

const agent = new ConversationAgent({
  // ... config
  telemetryCallback: (event) => {
    if (event.name === "ws_error") {
      console.error("WebSocket error:", event.properties.error);
    }
    if (event.name === "ws_disconnected") {
      console.log("Disconnected:", event.properties.reason);
    }
    if (event.name === "network_offline") {
      showOfflineWarning();
    }
    if (event.name === "network_online") {
      hideOfflineWarning();
    }
  },
});